Merge #255

255: Test improvements r=curquiza a=jmks

Some spec improvements mentioned in #230, addressing #233, namely:

* Eliminate the last instance variable (``@client`)`
* Replace a test global (`test_uid`) by using a test helper (I introduced this, but changed my mind 😄 )
* Use `describe`/`context` to describe methods for the indexes specs

Co-authored-by: Jason Schweier <[email protected]>

Author: bors[bot]

spec/meilisearch/client/indexes_spec.rb

@@ -1,142 +1,193 @@
 # frozen_string_literal: true
 
 RSpec.describe 'MeiliSearch::Client - Indexes' do
-  it 'creates an index without primary-key' do
-    index = client.create_index('index')
-    expect(index).to be_a(MeiliSearch::Index)
-    expect(index.uid).to eq('index')
-    expect(index.primary_key).to be_nil
-    expect(index.fetch_primary_key).to be_nil
-  end
-
-  it 'creates an index with primary-key' do
-    index = client.create_index('index', primaryKey: 'primary_key')
-    expect(index).to be_a(MeiliSearch::Index)
-    expect(index.uid).to eq('index')
-    expect(index.primary_key).to eq('primary_key')
-    expect(index.fetch_primary_key).to eq('primary_key')
-  end
+  describe '#create_index' do
+    context 'without a primary key' do
+      it 'creates an index' do
+        index = client.create_index('new_index')
+
+        expect(index).to be_a(MeiliSearch::Index)
+        expect(index.uid).to eq('new_index')
+        expect(index.primary_key).to be_nil
+        expect(index.fetch_primary_key).to be_nil
+      end
+    end
 
-  it 'creates an index with uid in options - should not take it into account' do
-    index = client.create_index('index', primaryKey: 'primary_key', uid: 'wrong')
-    expect(index).to be_a(MeiliSearch::Index)
-    expect(index.uid).to eq('index')
-    expect(index.primary_key).to eq('primary_key')
-    expect(index.fetch_primary_key).to eq('primary_key')
-  end
+    context 'with a primary key' do
+      it 'creates an index' do
+        index = client.create_index('new_index', primaryKey: 'primary_key')
+
+        expect(index).to be_a(MeiliSearch::Index)
+        expect(index.uid).to eq('new_index')
+        expect(index.primary_key).to eq('primary_key')
+        expect(index.fetch_primary_key).to eq('primary_key')
+      end
+
+      context 'when primary key option in snake_case' do
+        it 'creates an index' do
+          index = client.create_index('new_index', primary_key: 'primary_key')
+
+          expect(index).to be_a(MeiliSearch::Index)
+          expect(index.uid).to eq('new_index')
+          expect(index.primary_key).to eq('primary_key')
+          expect(index.fetch_primary_key).to eq('primary_key')
+        end
+      end
+
+      context 'when uid is provided as an option' do
+        it 'ignores the uid option' do
+          index = client.create_index(
+            'new_index',
+            primaryKey: 'primary_key',
+            uid: 'not_primary_key'
+          )
+
+          expect(index).to be_a(MeiliSearch::Index)
+          expect(index.uid).to eq('new_index')
+          expect(index.primary_key).to eq('primary_key')
+          expect(index.fetch_primary_key).to eq('primary_key')
+        end
+      end
+    end
 
-  it 'creates an new index with get_or_create_index method' do
-    expect do
-      index = client.get_or_create_index('index')
+    context 'when an index with a given uid already exists' do
+      it 'raises an error' do
+        client.create_index('existing_index')
 
-      expect(index).to be_a(MeiliSearch::Index)
-      expect(index.uid).to eq('index')
-      expect(index.primary_key).to be_nil
-    end.to(change { client.indexes.length }.by(1))
+        expect do
+          client.create_index('existing_index')
+        end.to raise_meilisearch_api_error_with(400, 'index_already_exists', 'invalid_request_error')
+      end
+    end
 
-    fetched_index = client.fetch_index('index')
-    expect(fetched_index.uid).to eq('index')
-    expect(fetched_index.primary_key).to be_nil
+    context 'when the uid format is invalid' do
+      it 'raises an error' do
+        expect do
+          client.create_index('two words')
+        end.to raise_meilisearch_api_error_with(400, 'invalid_index_uid', 'invalid_request_error')
+      end
+    end
   end
 
-  it 'creates an new index with get_or_create_index method and a primary-key' do
-    expect do
-      index = client.get_or_create_index('index', primaryKey: 'title')
+  describe '#get_or_create_index' do
+    it 'creates a new index' do
+      expect do
+        new_index = client.get_or_create_index('new_index')
 
-      expect(index).to be_a(MeiliSearch::Index)
-      expect(index.uid).to eq('index')
-      expect(index.primary_key).to eq('title')
-    end.to(change { client.indexes.length }.by(1))
+        expect(new_index).to be_a(MeiliSearch::Index)
+      end.to change { client.indexes.length }.by(1)
 
-    fetched_index = client.fetch_index('index')
-    expect(fetched_index.uid).to eq('index')
-    expect(fetched_index.primary_key).to eq('title')
-  end
+      found_index = client.fetch_index('new_index')
+      expect(found_index.uid).to eq('new_index')
+      expect(found_index.primary_key).to be_nil
+    end
 
-  it 'get an already existing index with get_or_create_index method' do
-    client.create_index(test_uid)
+    it 'gets an index that already exists' do
+      client.create_index('existing_index')
 
-    expect do
-      index = client.get_or_create_index(test_uid)
+      expect do
+        client.get_or_create_index('existing_index')
+      end.not_to(change { client.indexes.length })
+    end
 
-      expect(index).to be_a(MeiliSearch::Index)
-      expect(index.uid).to eq(test_uid)
-      expect(index.primary_key).to be_nil
-    end.not_to(change { client.indexes.length })
+    context 'when a primary key is provided' do
+      it 'creates a new index' do
+        expect do
+          index = client.get_or_create_index('new_index', primaryKey: 'primary_key')
+
+          expect(index).to be_a(MeiliSearch::Index)
+        end.to change { client.indexes.length }.by(1)
+      end
+    end
   end
 
-  it 'fails to create an index with an uid already taken' do
-    client.create_index(test_uid)
+  describe '#indexes' do
+    it 'returns MeiliSearch::Index objects' do
+      client.create_index('index')
 
-    expect do
-      client.create_index(test_uid)
-    end.to raise_meilisearch_api_error_with(400, 'index_already_exists', 'invalid_request_error')
-  end
+      response = client.indexes.first
 
-  it 'fails to create an index with bad UID format' do
-    expect do
-      client.create_index('two words')
-    end.to raise_meilisearch_api_error_with(400, 'invalid_index_uid', 'invalid_request_error')
-  end
+      expect(response).to be_a(MeiliSearch::Index)
+    end
 
-  it 'gets list of indexes as MeiliSearch::Index' do
-    client.create_index('index')
+    it 'gets a list of indexes' do
+      ['first_index', 'second_index', 'third_index'].each { |name| client.create_index(name) }
 
-    response = client.indexes.first
+      indexes = client.indexes
 
-    expect(response).to be_a(MeiliSearch::Index)
+      expect(indexes).to be_a(Array)
+      expect(indexes.length).to eq(3)
+      uids = indexes.map(&:uid)
+      expect(uids).to contain_exactly('first_index', 'second_index', 'third_index')
+    end
   end
 
-  it 'gets list of raw indexes' do
-    ['first_index', 'second_index', 'third_index'].each { |name| client.create_index(name) }
+  describe '#raw_indexes' do
+    it 'returns raw indexes' do
+      client.create_index('index')
 
-    indexes = client.raw_indexes
+      response = client.raw_indexes.first
 
-    expect(indexes).to be_a(Array)
-    expect(indexes.length).to eq(3)
-    uids = indexes.map { |elem| elem['uid'] }
-    expect(uids).to contain_exactly('first_index', 'second_index', 'third_index')
-  end
+      expect(response).to be_a(Hash)
+      expect(response['uid']).to eq('index')
+    end
 
-  it 'fetch a specific index' do
-    client.create_index('specific_index', primaryKey: 'primary_key')
+    it 'gets a list of raw indexes' do
+      ['first_index', 'second_index', 'third_index'].each { |name| client.create_index(name) }
 
-    response = client.fetch_index('specific_index')
+      indexes = client.raw_indexes
 
-    expect(response).to be_a(MeiliSearch::Index)
-    expect(response.uid).to eq('specific_index')
-    expect(response.primary_key).to eq('primary_key')
-    expect(response.fetch_primary_key).to eq('primary_key')
+      expect(indexes).to be_a(Array)
+      expect(indexes.length).to eq(3)
+      uids = indexes.map { |elem| elem['uid'] }
+      expect(uids).to contain_exactly('first_index', 'second_index', 'third_index')
+    end
   end
 
-  it 'returns an index object based on uid' do
-    client.create_index('index_with_pk', primaryKey: 'primary_key')
+  describe '#fetch_index' do
+    it 'fetches index by uid' do
+      client.create_index('new_index', primaryKey: 'primary_key')
 
-    index = client.index('index_with_pk')
+      fetched_index = client.fetch_index('new_index')
 
-    expect(index).to be_a(MeiliSearch::Index)
-    expect(index.uid).to eq('index_with_pk')
-    expect(index.primary_key).to be_nil
-    expect(index.fetch_primary_key).to eq('primary_key')
-    expect(index.primary_key).to eq('primary_key')
+      expect(fetched_index).to be_a(MeiliSearch::Index)
+      expect(fetched_index.uid).to eq('new_index')
+      expect(fetched_index.primary_key).to eq('primary_key')
+      expect(fetched_index.fetch_primary_key).to eq('primary_key')
+    end
   end
 
-  it 'deletes an index' do
-    client.create_index('index')
+  describe '#index' do
+    it 'returns an index object with the provided uid' do
+      client.create_index('existing_index', primaryKey: 'primary_key')
+
+      # this index is in memory, without metadata from server
+      index = client.index('existing_index')
+
+      expect(index).to be_a(MeiliSearch::Index)
+      expect(index.uid).to eq('existing_index')
+      expect(index.primary_key).to be_nil
 
-    expect do
-      expect(client.delete_index('index')).to be_nil
-    end.to(change { client.indexes.length }.by(-1))
+      # fetch primary key metadata from server
+      expect(index.fetch_primary_key).to eq('primary_key')
+      expect(index.primary_key).to eq('primary_key')
+    end
   end
 
-  context 'with snake_case options' do
-    it 'creates an index without errors' do
-      uid = SecureRandom.uuid
+  describe '#delete_index' do
+    context 'when the index exists' do
+      it 'deletes the index' do
+        client.create_index('existing_index')
 
-      expect do
-        client.create_index(uid, primary_key: @primary_key)
-        client.fetch_index(uid)
-      end.to_not raise_error
+        expect(client.delete_index('existing_index')).to be_nil
+        expect { client.fetch_index('existing_index') }.to raise_index_not_found_meilisearch_api_error
+      end
+    end
+
+    context 'when the index does not exist' do
+      it 'raises an index not found error' do
+        expect { client.delete_index('index_does_not_exist') }.to raise_index_not_found_meilisearch_api_error
+      end
     end
   end
 end

spec/meilisearch/client/keys_spec.rb

@@ -14,7 +14,7 @@
     public_key = client.keys['public']
     new_client = MeiliSearch::Client.new(URL, public_key)
     expect do
-      new_client.index(test_uid).settings
+      new_client.index(random_uid).settings
     end.to raise_meilisearch_api_error_with(403, 'invalid_token', 'authentication_error')
   end
 
@@ -29,26 +29,28 @@
   it 'fails to search if no key used' do
     new_client = MeiliSearch::Client.new(URL)
     expect do
-      new_client.index(test_uid).settings
+      new_client.index(random_uid).settings
     end.to raise_meilisearch_api_error_with(401, 'missing_authorization_header', 'authentication_error')
   end
 
   it 'succeeds to search when using public key' do
+    uid = random_uid
     public_key = client.keys['public']
-    index = client.create_index(test_uid)
+    index = client.create_index(uid)
     response = index.add_documents(title: 'Test')
     index.wait_for_pending_update(response['updateId'])
 
     new_client = MeiliSearch::Client.new(URL, public_key)
-    response = new_client.index(test_uid).search('test')
+    response = new_client.index(uid).search('test')
     expect(response).to have_key('hits')
   end
 
   it 'succeeds to get settings when using private key' do
-    client.create_index(test_uid)
+    uid = random_uid
+    client.create_index(uid)
     private_key = client.keys['private']
     new_client = MeiliSearch::Client.new(URL, private_key)
-    response = new_client.index(test_uid).settings
+    response = new_client.index(uid).settings
     expect(response).to have_key('rankingRules')
   end
 

spec/meilisearch/client/requests_spec.rb

@@ -4,18 +4,16 @@
   let(:key) { SecureRandom.uuid }
 
   before(:each) do
-    @client = MeiliSearch::Client.new(URL, MASTER_KEY)
-
     expect(MeiliSearch::Client).to receive(:post)
       .with(kind_of(String), hash_including(body: "{\"primaryKey\":\"#{key}\",\"uid\":\"#{key}\"}"))
       .and_call_original
   end
 
   it 'parses options when they are in a snake_case' do
-    @client.create_index(key, primary_key: key)
+    client.create_index(key, primary_key: key)
   end
 
   it 'parses options when they are in a different shape' do
-    @client.create_index(key, priMARy_kEy: key)
+    client.create_index(key, priMARy_kEy: key)
   end
 end

spec/meilisearch/index/documents_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 RSpec.describe 'MeiliSearch::Index - Documents' do
-  let(:index) { client.create_index(test_uid) }
+  let(:index) { client.create_index(random_uid) }
 
   context 'All basic tests with primary-key inference' do
     let(:documents) do

spec/support/default_shared_context.rb

@@ -2,7 +2,6 @@
 
 RSpec.shared_context 'test defaults' do
   let(:client) { MeiliSearch::Client.new(URL, MASTER_KEY) }
-  let(:test_uid) { random_uid }
 
   before do
     clear_all_indexes(client)