elasticsearch-persistence 5.1.0 → 6.0.0.pre

data/spec/repository/serialize_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Elasticsearch::Persistence::Repository::Serialize do
+
+  let(:repository) do
+    DEFAULT_REPOSITORY
+  end
+
+  describe '#serialize' do
+
+    before do
+      class MyDocument
+        def to_hash
+          { a: 1 }
+        end
+      end
+    end
+
+    it 'calls #to_hash on the object' do
+      expect(repository.serialize(MyDocument.new)).to eq(a: 1)
+    end
+  end
+
+  describe '#deserialize' do
+
+    context 'when klass is defined on the Repository' do
+
+      let(:repository) do
+        require 'set'
+        MyTestRepository.new(klass: Set)
+      end
+
+      it 'instantiates an object of the klass' do
+        expect(repository.deserialize('_source' => { a: 1 })).to be_a(Set)
+      end
+
+      it 'uses the source field to instantiate the object' do
+        expect(repository.deserialize('_source' => { a: 1 })).to eq(Set.new({ a: 1}))
+      end
+    end
+
+    context 'when klass is not defined on the Repository' do
+
+      it 'returns the raw Hash' do
+        expect(repository.deserialize('_source' => { a: 1 })).to be_a(Hash)
+      end
+
+      it 'uses the source field to instantiate the object' do
+        expect(repository.deserialize('_source' => { a: 1 })).to eq(a: 1)
+      end
+    end
+  end
+end

data/spec/repository/store_spec.rb

@@ -0,0 +1,327 @@
+require 'spec_helper'
+
+describe Elasticsearch::Persistence::Repository::Store do
+
+  let(:repository) do
+    DEFAULT_REPOSITORY
+  end
+
+  after do
+    begin; repository.delete_index!; rescue; end
+  end
+
+  describe '#save' do
+
+    let(:document) do
+      { a: 1 }
+    end
+
+    let(:response) do
+      repository.save(document)
+    end
+
+    it 'saves the document' do
+      expect(repository.find(response['_id'])).to eq('a' => 1)
+    end
+
+    context 'when the repository defines a custom serialize method' do
+
+      before do
+        class OtherNoteRepository
+          include Elasticsearch::Persistence::Repository
+          def serialize(document)
+            { b: 1 }
+          end
+        end
+      end
+
+      after do
+        if defined?(OtherNoteRepository)
+          Object.send(:remove_const, OtherNoteRepository.name)
+        end
+      end
+
+      let(:repository) do
+        OtherNoteRepository.new(client: DEFAULT_CLIENT)
+      end
+
+      let(:response) do
+        repository.save(document)
+      end
+
+      it 'saves the document' do
+        expect(repository.find(response['_id'])).to eq('b' => 1)
+      end
+    end
+
+    context 'when options are provided' do
+
+      let!(:response) do
+        repository.save(document, type: 'other_note')
+      end
+
+      it 'saves the document using the options' do
+        expect {
+          repository.find(response['_id'])
+        }.to raise_exception(Elasticsearch::Persistence::Repository::DocumentNotFound)
+        expect(repository.find(response['_id'], type: 'other_note')).to eq('a' => 1)
+      end
+    end
+  end
+
+  describe '#update' do
+
+    before(:all) do
+      class Note
+        def to_hash
+          { text: 'testing', views: 0 }
+        end
+      end
+    end
+
+    after(:all) do
+      if defined?(Note)
+        Object.send(:remove_const, :Note)
+      end
+    end
+
+    context 'when the document exists' do
+
+      let!(:id) do
+        repository.save(Note.new)['_id']
+      end
+
+      context 'when an id is provided' do
+
+        context 'when a doc is specified in the options' do
+
+          before do
+            repository.update(id, doc: { text: 'testing_2' })
+          end
+
+          it 'updates using the doc parameter' do
+            expect(repository.find(id)).to eq('text' => 'testing_2', 'views' => 0)
+          end
+        end
+
+        context 'when a script is specified in the options' do
+
+          before do
+            repository.update(id, script: { inline: 'ctx._source.views += 1' })
+          end
+
+          it 'updates using the script parameter' do
+            expect(repository.find(id)).to eq('text' => 'testing', 'views' => 1)
+          end
+        end
+
+        context 'when params are specified in the options' do
+
+          before do
+            repository.update(id, script: { inline: 'ctx._source.views += params.count',
+                                            params: { count: 2 } })
+          end
+
+          it 'updates using the script parameter' do
+            expect(repository.find(id)).to eq('text' => 'testing', 'views' => 2)
+          end
+        end
+
+        context 'when upsert is specified in the options' do
+
+          before do
+            repository.update(id, script: { inline: 'ctx._source.views += 1' },
+                                  upsert: { text: 'testing_2' })
+          end
+
+          it 'executes the script' do
+            expect(repository.find(id)).to eq('text' => 'testing', 'views' => 1)
+          end
+        end
+
+        context 'when doc_as_upsert is specified in the options' do
+
+          before do
+            repository.update(id, doc: { text: 'testing_2' },
+                                  doc_as_upsert: true)
+          end
+
+          it 'performs an upsert' do
+            expect(repository.find(id)).to eq('text' => 'testing_2', 'views' => 0)
+          end
+        end
+      end
+
+      context 'when a document is provided as the query criteria' do
+
+        context 'when no options are provided' do
+
+          before do
+            repository.update(id: id, text: 'testing_2')
+          end
+
+          it 'updates using the id and the document as the doc parameter' do
+            expect(repository.find(id)).to eq('text' => 'testing_2', 'views' => 0)
+          end
+        end
+
+        context 'when options are provided' do
+
+          context 'when a doc is specified in the options' do
+
+            before do
+              repository.update({ id: id, text: 'testing' }, doc: { text: 'testing_2' })
+            end
+
+            it 'updates using the id and the doc in the options' do
+              expect(repository.find(id)).to eq('text' => 'testing_2', 'views' => 0)
+            end
+          end
+
+          context 'when a script is specified in the options' do
+
+            before do
+              repository.update({ id: id, text: 'testing' },
+                                script: { inline: 'ctx._source.views += 1' })
+            end
+
+            it 'updates using the id and script from the options' do
+              expect(repository.find(id)).to eq('text' => 'testing', 'views' => 1)
+            end
+          end
+
+          context 'when params are specified in the options' do
+
+            before do
+              repository.update({ id: id, text: 'testing' },
+                                script: { inline: 'ctx._source.views += params.count',
+                                          params: { count: 2 } })
+            end
+
+            it 'updates using the id and script and params from the options' do
+              expect(repository.find(id)).to eq('text' => 'testing', 'views' => 2)
+            end
+          end
+
+          context 'when upsert is specified in the options' do
+
+            before do
+              repository.update({ id: id, text: 'testing_2' },
+                                doc_as_upsert: true)
+            end
+
+            it 'updates using the id and script and params from the options' do
+              expect(repository.find(id)).to eq('text' => 'testing_2', 'views' => 0)
+            end
+          end
+        end
+      end
+    end
+
+    context 'when the document does not exist' do
+
+      context 'when an id is provided 'do
+
+        it 'raises an exception' do
+          expect {
+            repository.update(1, doc: { text: 'testing_2' })
+          }.to raise_exception(Elasticsearch::Transport::Transport::Errors::NotFound)
+        end
+
+        context 'when upsert is provided' do
+
+          before do
+            repository.update(1, doc: { text: 'testing' }, doc_as_upsert: true)
+          end
+
+          it 'upserts the document' do
+            expect(repository.find(1)).to eq('text' => 'testing')
+          end
+        end
+      end
+
+      context 'when a document is provided' do
+
+        it 'raises an exception' do
+          expect {
+            repository.update(id: 1, text: 'testing_2')
+          }.to raise_exception(Elasticsearch::Transport::Transport::Errors::NotFound)
+        end
+
+        context 'when upsert is provided' do
+
+          before do
+            repository.update({ id: 1, text: 'testing' }, doc_as_upsert: true)
+          end
+
+          it 'upserts the document' do
+            expect(repository.find(1)).to eq('text' => 'testing')
+          end
+        end
+      end
+    end
+  end
+
+  describe '#delete' do
+
+    before(:all) do
+      class Note
+        def to_hash
+          { text: 'testing', views: 0 }
+        end
+      end
+    end
+
+    after(:all) do
+      if defined?(Note)
+        Object.send(:remove_const, :Note)
+      end
+    end
+
+    context 'when the document exists' do
+
+      let!(:id) do
+        repository.save(Note.new)['_id']
+      end
+
+      context 'an id is provided' do
+
+        before do
+          repository.delete(id)
+        end
+
+        it 'deletes the document using the id' do
+          expect {
+            repository.find(id)
+          }.to raise_exception(Elasticsearch::Persistence::Repository::DocumentNotFound)
+        end
+      end
+
+      context 'when a document is provided' do
+
+        before do
+          repository.delete(id: id, text: 'testing')
+        end
+
+        it 'deletes the document using the document' do
+          expect {
+            repository.find(id)
+          }.to raise_exception(Elasticsearch::Persistence::Repository::DocumentNotFound)
+        end
+      end
+    end
+
+    context 'when the document does not exist' do
+
+      before do
+        repository.create_index!
+      end
+
+      it 'raises an exception' do
+        expect {
+          repository.delete(1)
+        }.to raise_exception(Elasticsearch::Transport::Transport::Errors::NotFound)
+      end
+    end
+  end
+end

data/spec/repository_spec.rb

@@ -0,0 +1,716 @@
+require 'spec_helper'
+
+describe Elasticsearch::Persistence::Repository do
+
+  describe '#create' do
+
+    before(:all) do
+      class RepositoryWithoutDSL
+        include Elasticsearch::Persistence::Repository
+      end
+    end
+
+    after(:all) do
+      if defined?(RepositoryWithoutDSL)
+        Object.send(:remove_const, RepositoryWithoutDSL.name)
+      end
+    end
+
+    it 'creates a repository object' do
+      expect(RepositoryWithoutDSL.create).to be_a(RepositoryWithoutDSL)
+    end
+
+    context 'when options are provided' do
+
+      let(:repository) do
+        RepositoryWithoutDSL.create(document_type: 'note')
+      end
+
+      it 'sets the options on the instance' do
+        expect(repository.document_type).to eq('note')
+      end
+    end
+
+    context 'when a block is passed' do
+
+      let(:repository) do
+        RepositoryWithoutDSL.create(document_type: 'note') do
+          mapping dynamic: 'strict' do
+            indexes :foo
+          end
+        end
+      end
+
+      it 'executes the block on the instance' do
+        expect(repository.mapping.to_hash).to eq(note: { dynamic: 'strict', properties: { foo: { type: 'text' } } })
+      end
+
+      context 'when options are provided in the args and set in the block' do
+
+        let(:repository) do
+          RepositoryWithoutDSL.create(mapping: double('mapping', to_hash: {}), document_type: 'note') do
+            mapping dynamic: 'strict' do
+              indexes :foo
+            end
+          end
+        end
+
+        it 'uses the options from the args' do
+          expect(repository.mapping.to_hash).to eq({})
+        end
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    before(:all) do
+      class RepositoryWithoutDSL
+        include Elasticsearch::Persistence::Repository
+      end
+    end
+
+    after(:all) do
+      if defined?(RepositoryWithoutDSL)
+        Object.send(:remove_const, RepositoryWithoutDSL.name)
+      end
+    end
+
+    after do
+      begin; repository.delete_index!; rescue; end
+    end
+
+    context 'when options are not provided' do
+
+      let(:repository) do
+        RepositoryWithoutDSL.new
+      end
+
+      it 'sets a default client' do
+        expect(repository.client).to be_a(Elasticsearch::Transport::Client)
+      end
+
+      it 'sets a default document type' do
+        expect(repository.document_type).to eq('_doc')
+      end
+
+      it 'sets a default index name' do
+        expect(repository.index_name).to eq('repository')
+      end
+
+      it 'does not set a klass' do
+        expect(repository.klass).to be_nil
+      end
+    end
+
+    context 'when options are provided' do
+
+      let(:client) do
+        Elasticsearch::Client.new
+      end
+
+      let(:repository) do
+        RepositoryWithoutDSL.new(client: client, document_type: 'user', index_name: 'users', klass: Array)
+      end
+
+      it 'sets the client' do
+        expect(repository.client).to be(client)
+      end
+
+      it 'sets document type' do
+        expect(repository.document_type).to eq('user')
+      end
+
+      it 'sets index name' do
+        expect(repository.index_name).to eq('users')
+      end
+
+      it 'sets the klass' do
+        expect(repository.klass).to eq(Array)
+      end
+    end
+  end
+
+  context 'when the DSL module is included' do
+
+    before(:all) do
+      class RepositoryWithDSL
+        include Elasticsearch::Persistence::Repository
+        include Elasticsearch::Persistence::Repository::DSL
+
+        document_type 'note'
+        index_name 'notes_repo'
+        klass Hash
+        client DEFAULT_CLIENT
+
+        settings number_of_shards: 1, number_of_replicas: 0 do
+          mapping dynamic: 'strict' do
+            indexes :foo do
+              indexes :bar
+            end
+            indexes :baz
+          end
+        end
+      end
+    end
+
+    after(:all) do
+      if defined?(RepositoryWithDSL)
+        Object.send(:remove_const, RepositoryWithDSL.name)
+      end
+    end
+
+    after do
+      begin; repository.delete_index; rescue; end
+    end
+
+    context '#client' do
+
+      it 'allows the value to be set only once on the class' do
+        RepositoryWithDSL.client(double('client', class: 'other_client'))
+        expect(RepositoryWithDSL.client).to be(DEFAULT_CLIENT)
+      end
+
+      it 'sets the value at the class level' do
+        expect(RepositoryWithDSL.client).to be(DEFAULT_CLIENT)
+      end
+
+      it 'sets the value as the default at the instance level' do
+        expect(RepositoryWithDSL.new.client).to be(DEFAULT_CLIENT)
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithDSL.new(client: double('client', instance: 'other')).client.instance).to eq('other')
+      end
+    end
+
+    context '#klass' do
+
+      it 'allows the value to be set only once on the class' do
+        RepositoryWithDSL.klass(Array)
+        expect(RepositoryWithDSL.klass).to eq(Hash)
+      end
+
+      it 'sets the value at the class level' do
+        expect(RepositoryWithDSL.klass).to eq(Hash)
+      end
+
+      it 'sets the value as the default at the instance level' do
+        expect(RepositoryWithDSL.new.klass).to eq(Hash)
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithDSL.new(klass: Array).klass).to eq(Array)
+      end
+
+      context 'when nil is passed to the method' do
+
+        before do
+          RepositoryWithDSL.klass(nil)
+        end
+
+        it 'allows the value to be set only once' do
+          expect(RepositoryWithDSL.klass).to eq(Hash)
+        end
+      end
+    end
+
+    context '#document_type' do
+
+      it 'allows the value to be set only once on the class' do
+        RepositoryWithDSL.document_type('other_note')
+        expect(RepositoryWithDSL.document_type).to eq('note')
+      end
+
+      it 'sets the value at the class level' do
+        expect(RepositoryWithDSL.document_type).to eq('note')
+      end
+
+      it 'sets the value as the default at the instance level' do
+        expect(RepositoryWithDSL.new.document_type).to eq('note')
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithDSL.new(document_type: 'other_note').document_type).to eq('other_note')
+      end
+    end
+
+    context '#index_name' do
+
+      it 'allows the value to be set only once on the class' do
+        RepositoryWithDSL.index_name('other_name')
+        expect(RepositoryWithDSL.index_name).to eq('notes_repo')
+      end
+
+      it 'sets the value at the class level' do
+        expect(RepositoryWithDSL.index_name).to eq('notes_repo')
+      end
+
+      it 'sets the value as the default at the instance level' do
+        expect(RepositoryWithDSL.new.index_name).to eq('notes_repo')
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithDSL.new(index_name: 'other_notes_repo').index_name).to eq('other_notes_repo')
+      end
+    end
+
+    describe '#create_index!' do
+
+      context 'when the method is called on an instance' do
+
+        let(:repository) do
+          RepositoryWithDSL.new
+        end
+
+        before do
+          begin; repository.delete_index!; rescue; end
+          repository.create_index!
+        end
+
+        it 'creates the index' do
+          expect(repository.index_exists?).to be(true)
+        end
+      end
+
+      context 'when the method is called on the class' do
+
+        it 'raises a NotImplementedError' do
+          expect {
+            RepositoryWithDSL.create_index!
+          }.to raise_exception(NotImplementedError)
+        end
+      end
+    end
+
+    describe '#delete_index!' do
+
+      context 'when the method is called on an instance' do
+
+        let(:repository) do
+          RepositoryWithDSL.new
+        end
+
+        before do
+          repository.create_index!
+          begin; repository.delete_index!; rescue; end
+        end
+
+        it 'deletes the index' do
+          expect(repository.index_exists?).to be(false)
+        end
+      end
+
+      context 'when the method is called on the class' do
+
+        it 'raises a NotImplementedError' do
+          expect {
+            RepositoryWithDSL.delete_index!
+          }.to raise_exception(NotImplementedError)
+        end
+      end
+    end
+
+    describe '#refresh_index!' do
+
+      context 'when the method is called on an instance' do
+
+        let(:repository) do
+          RepositoryWithDSL.new
+        end
+
+        before do
+          repository.create_index!
+        end
+
+        it 'refreshes the index' do
+          expect(repository.refresh_index!['_shards']).to be_a(Hash)
+        end
+      end
+
+      context 'when the method is called on the class' do
+
+        it 'raises a NotImplementedError' do
+          expect {
+            RepositoryWithDSL.refresh_index!
+          }.to raise_exception(NotImplementedError)
+        end
+      end
+    end
+
+    describe '#index_exists?' do
+
+      context 'when the method is called on an instance' do
+
+        let(:repository) do
+          RepositoryWithDSL.new
+        end
+
+        before do
+          repository.create_index!
+        end
+
+        it 'determines if the index exists' do
+          expect(repository.index_exists?).to be(true)
+        end
+      end
+
+      context 'when the method is called on the class' do
+
+        it 'raises a NotImplementedError' do
+          expect {
+            RepositoryWithDSL.index_exists?
+          }.to raise_exception(NotImplementedError)
+        end
+      end
+    end
+
+    describe '#mapping' do
+
+      let(:expected_mapping) do
+        { note: { dynamic: 'strict',
+                  properties: { foo: { type: 'object',
+                                       properties: { bar: { type: 'text' } } },
+                                baz: { type: 'text' } }
+                }
+        }
+      end
+
+      it 'sets the value at the class level' do
+        expect(RepositoryWithDSL.mapping.to_hash).to eq(expected_mapping)
+      end
+
+      it 'sets the value as the default at the instance level' do
+        expect(RepositoryWithDSL.new.mapping.to_hash).to eq(expected_mapping)
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithDSL.new(mapping: double('mapping', to_hash: { note: {} })).mapping.to_hash).to eq(note: {})
+      end
+
+      context 'when the instance has a different document type' do
+
+        let(:expected_mapping) do
+          { other_note: { dynamic: 'strict',
+                          properties: { foo: { type: 'object',
+                                               properties: { bar: { type: 'text' } } },
+                                        baz: { type: 'text' } }
+                        }
+          }
+        end
+
+        it 'updates the mapping to use the document type' do
+          expect(RepositoryWithDSL.new(document_type: 'other_note').mapping.to_hash).to eq(expected_mapping)
+        end
+      end
+    end
+
+    describe '#settings' do
+
+      it 'sets the value at the class level' do
+        expect(RepositoryWithDSL.settings.to_hash).to eq(number_of_shards: 1, number_of_replicas: 0)
+      end
+
+      it 'sets the value as the default at the instance level' do
+        expect(RepositoryWithDSL.new.settings.to_hash).to eq(number_of_shards: 1, number_of_replicas: 0)
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithDSL.new(settings: { number_of_shards: 3 }).settings.to_hash).to eq({number_of_shards: 3})
+      end
+    end
+  end
+
+  context 'when the DSL module is not included' do
+
+    before(:all) do
+      class RepositoryWithoutDSL
+        include Elasticsearch::Persistence::Repository
+      end
+    end
+
+    after(:all) do
+      if defined?(RepositoryWithoutDSL)
+        Object.send(:remove_const, RepositoryWithoutDSL.name)
+      end
+    end
+
+    context '#client' do
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.client
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'sets a default on the instance' do
+        expect(RepositoryWithoutDSL.new.client).to be_a(Elasticsearch::Transport::Client)
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithoutDSL.new(client: double('client', object_id: 123)).client.object_id).to eq(123)
+      end
+    end
+
+    context '#klass' do
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.klass
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'does not set a default on an instance' do
+        expect(RepositoryWithoutDSL.new.klass).to be_nil
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithoutDSL.new(klass: Array).klass).to eq(Array)
+      end
+    end
+
+    context '#document_type' do
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.document_type
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'sets a default on the instance' do
+        expect(RepositoryWithoutDSL.new.document_type).to eq('_doc')
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithoutDSL.new(document_type: 'notes').document_type).to eq('notes')
+      end
+    end
+
+    context '#index_name' do
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.index_name
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'sets a default on the instance' do
+        expect(RepositoryWithoutDSL.new.index_name).to eq('repository')
+      end
+
+      it 'allows the value to be overridden with options on the instance' do
+        expect(RepositoryWithoutDSL.new(index_name: 'notes_repository').index_name).to eq('notes_repository')
+      end
+    end
+
+    describe '#create_index!' do
+
+      let(:repository) do
+        RepositoryWithoutDSL.new(client: DEFAULT_CLIENT)
+      end
+
+      after do
+        begin; repository.delete_index!; rescue; end
+      end
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.create_index!
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'creates an index' do
+        repository.create_index!
+        expect(repository.index_exists?).to eq(true)
+      end
+    end
+
+    describe '#delete_index!' do
+
+      let(:repository) do
+        RepositoryWithoutDSL.new(client: DEFAULT_CLIENT)
+      end
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.delete_index!
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'deletes an index' do
+        repository.create_index!
+        repository.delete_index!
+        expect(repository.index_exists?).to eq(false)
+      end
+    end
+
+    describe '#refresh_index!' do
+
+      let(:repository) do
+        RepositoryWithoutDSL.new(client: DEFAULT_CLIENT)
+      end
+
+      after do
+        begin; repository.delete_index!; rescue; end
+      end
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.refresh_index!
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'refreshes an index' do
+        repository.create_index!
+        expect(repository.refresh_index!['_shards']).to be_a(Hash)
+      end
+    end
+
+    describe '#index_exists?' do
+
+      let(:repository) do
+        RepositoryWithoutDSL.new(client: DEFAULT_CLIENT)
+      end
+
+      after do
+        begin; repository.delete_index!; rescue; end
+      end
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.index_exists?
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'returns whether the index exists' do
+        repository.create_index!
+        expect(repository.index_exists?).to be(true)
+      end
+    end
+
+    describe '#mapping' do
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.mapping
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'sets a default on an instance' do
+        expect(RepositoryWithoutDSL.new.mapping.to_hash).to eq(_doc: { properties: {} })
+      end
+
+      it 'allows the mapping to be set as an option' do
+        expect(RepositoryWithoutDSL.new(mapping: double('mapping', to_hash: { note: {} })).mapping.to_hash).to eq(note: {})
+      end
+
+      context 'when a block is passed to the create method' do
+
+        let(:expected_mapping) do
+          { note: { dynamic: 'strict',
+                    properties: { foo: { type: 'object',
+                                         properties: { bar: { type: 'text' } } },
+                                  baz: { type: 'text' } }
+            }
+          }
+        end
+
+        let(:repository) do
+          RepositoryWithoutDSL.create(document_type: 'note') do
+            mapping dynamic: 'strict' do
+              indexes :foo do
+                indexes :bar
+              end
+              indexes :baz
+            end
+          end
+        end
+
+        it 'allows the mapping to be set in the block' do
+          expect(repository.mapping.to_hash).to eq(expected_mapping)
+        end
+
+        context 'when the mapping is set in the options' do
+
+          let(:repository) do
+            RepositoryWithoutDSL.create(mapping: double('mapping', to_hash: { note: {} })) do
+              mapping dynamic: 'strict' do
+                indexes :foo do
+                  indexes :bar
+                end
+                indexes :baz
+              end
+            end
+          end
+
+          it 'uses the mapping from the options' do
+            expect(repository.mapping.to_hash).to eq(note: {})
+          end
+        end
+      end
+    end
+
+    describe '#settings' do
+
+      it 'does not define the method at the class level' do
+        expect {
+          RepositoryWithoutDSL.settings
+        }.to raise_exception(NoMethodError)
+      end
+
+      it 'sets a default on an instance' do
+        expect(RepositoryWithoutDSL.new.settings.to_hash).to eq({})
+      end
+
+      it 'allows the settings to be set as an option' do
+        expect(RepositoryWithoutDSL.new(settings: double('settings', to_hash: {})).settings.to_hash).to eq({})
+      end
+
+      context 'when a block is passed to the #create method' do
+
+        let(:repository) do
+          RepositoryWithoutDSL.create(document_type: 'note') do
+            settings number_of_shards: 1, number_of_replicas: 0
+          end
+        end
+
+        it 'allows the settings to be set with a block' do
+          expect(repository.settings.to_hash).to eq(number_of_shards: 1, number_of_replicas: 0)
+        end
+
+        context 'when a mapping is set in the block as well' do
+
+          let(:expected_mapping) do
+            { note: { dynamic: 'strict',
+                      properties: { foo: { type: 'object',
+                                           properties: { bar: { type: 'text' } } },
+                                    baz: { type: 'text' } }
+                    }
+            }
+          end
+
+          let(:repository) do
+            RepositoryWithoutDSL.create(document_type: 'note') do
+              settings number_of_shards: 1, number_of_replicas: 0 do
+                mapping dynamic: 'strict' do
+                  indexes :foo do
+                    indexes :bar
+                  end
+                  indexes :baz
+                end
+              end
+            end
+          end
+
+          it 'allows the settings to be set with a block' do
+            expect(repository.settings.to_hash).to eq(number_of_shards: 1, number_of_replicas: 0)
+          end
+
+          it 'allows the mapping to be set with a block' do
+            expect(repository.mappings.to_hash).to eq(expected_mapping)
+          end
+        end
+      end
+    end
+  end
+end