Merge #230

230: Make tests independent r=curquiza a=jmks

Hello!

This is a fix for #122 - Make the tests independent.

My approach was this:
  * Delete all indexes at the start of each test example
  * Fix all the failures

In the end, I was able to enable RSpec to run the specs in a random order, which should help detect any additional dependent tests. I've run the full test suite locally many times now and only seen a transient error; however, a dependent test could still be lurking in the suite somewhere.

The transient error was that synonyms were being update then queried, without waiting for the updates to complete first.

A notable change that is not obvious from the code is that the test suite is slower now (for me, 19s instead of 8s, or ~2.5x slower). I suppose that's a tradeoff for clearing all indexes before each example runs.

The PR is also quite large 😬 

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

Author: bors[bot]

spec/meilisearch/client/dumps_spec.rb

@@ -1,34 +1,29 @@
 # frozen_string_literal: true
 
 RSpec.describe 'MeiliSearch::Client - Dumps' do
-  before(:all) do
-    @client = MeiliSearch::Client.new(URL, MASTER_KEY)
-    clear_all_indexes(@client)
-  end
-
   it 'creates a new dump' do
-    response = @client.create_dump
+    response = client.create_dump
     expect(response).to be_a(Hash)
     expect(response['uid']).to_not be_nil
     expect(response['status']).to_not be_nil
     expect(response['status']).to eq('in_progress')
-    wait_for_dump_creation(@client, response['uid'])
+    wait_for_dump_creation(client, response['uid'])
   end
 
   it 'gets dump status' do
-    dump = @client.create_dump
-    response = @client.dump_status(dump['uid'])
+    dump = client.create_dump
+    response = client.dump_status(dump['uid'])
     expect(response['status']).to_not be_nil
-    wait_for_dump_creation(@client, dump['uid'])
+    wait_for_dump_creation(client, dump['uid'])
   end
 
   it 'fails to get dump status without uid' do
     expect do
-      @client.dump_status('uid_not_exists')
+      client.dump_status('uid_not_exists')
     end.to raise_meilisearch_api_error_with(404, 'not_found', 'invalid_request_error')
   end
 
   it 'works with method aliases' do
-    expect(@client.method(:dump_status) == @client.method(:get_dump_status)).to be_truthy
+    expect(client.method(:dump_status) == client.method(:get_dump_status)).to be_truthy
   end
 end

spec/meilisearch/client/indexes_spec.rb

@@ -1,139 +1,133 @@
 # frozen_string_literal: true
 
 RSpec.describe 'MeiliSearch::Client - Indexes' do
-  before(:all) do
-    @client = MeiliSearch::Client.new(URL, MASTER_KEY)
-    clear_all_indexes(@client)
-    @uid1 = 'uid1'
-    @uid2 = 'uid2'
-    @uid3 = 'uid3'
-    @uid4 = 'uid4'
-    @uid5 = 'uid5'
-    @uid6 = 'uid6'
-    @uid7 = 'uid7'
-    @primary_key = 'objectId'
-  end
-
   it 'creates an index without primary-key' do
-    index = @client.create_index(@uid1)
+    index = client.create_index('index')
     expect(index).to be_a(MeiliSearch::Index)
-    expect(index.uid).to eq(@uid1)
+    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(@uid2, primaryKey: @primary_key)
+    index = client.create_index('index', primaryKey: 'primary_key')
     expect(index).to be_a(MeiliSearch::Index)
-    expect(index.uid).to eq(@uid2)
-    expect(index.primary_key).to eq(@primary_key)
-    expect(index.fetch_primary_key).to eq(@primary_key)
+    expect(index.uid).to eq('index')
+    expect(index.primary_key).to eq('primary_key')
+    expect(index.fetch_primary_key).to eq('primary_key')
   end
 
   it 'creates an index with uid in options - should not take it into account' do
-    index = @client.create_index(@uid3, primaryKey: @primary_key, uid: 'wrong')
+    index = client.create_index('index', primaryKey: 'primary_key', uid: 'wrong')
     expect(index).to be_a(MeiliSearch::Index)
-    expect(index.uid).to eq(@uid3)
-    expect(index.primary_key).to eq(@primary_key)
-    expect(index.fetch_primary_key).to eq(@primary_key)
+    expect(index.uid).to eq('index')
+    expect(index.primary_key).to eq('primary_key')
+    expect(index.fetch_primary_key).to eq('primary_key')
   end
 
   it 'creates an new index with get_or_create_index method' do
-    index = @client.get_or_create_index(@uid4)
-    expect(index).to be_a(MeiliSearch::Index)
-    expect(@client.indexes.count).to eq(4)
-    expect(@client.fetch_index(@uid4).uid).to eq(index.uid)
-    expect(@client.fetch_index(@uid4).uid).to eq(@uid4)
-    expect(@client.fetch_index(@uid4).primary_key).to be_nil
-    expect(@client.fetch_index(@uid4).primary_key).to eq(index.primary_key)
+    expect do
+      index = client.get_or_create_index('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))
+
+    fetched_index = client.fetch_index('index')
+    expect(fetched_index.uid).to eq('index')
+    expect(fetched_index.primary_key).to be_nil
   end
 
   it 'creates an new index with get_or_create_index method and a primary-key' do
-    index = @client.get_or_create_index(@uid5, primaryKey: 'title')
-    expect(index).to be_a(MeiliSearch::Index)
-    expect(@client.indexes.count).to eq(5)
-    expect(@client.fetch_index(@uid5).uid).to eq(index.uid)
-    expect(@client.fetch_index(@uid5).uid).to eq(@uid5)
-    expect(@client.fetch_index(@uid5).primary_key).to eq(index.primary_key)
-    expect(@client.fetch_index(@uid5).primary_key).to eq('title')
+    expect do
+      index = client.get_or_create_index('index', primaryKey: 'title')
+
+      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))
+
+    fetched_index = client.fetch_index('index')
+    expect(fetched_index.uid).to eq('index')
+    expect(fetched_index.primary_key).to eq('title')
   end
 
   it 'get an already existing index with get_or_create_index method' do
-    index = @client.get_or_create_index(@uid5)
-    expect(index).to be_a(MeiliSearch::Index)
-    expect(@client.indexes.count).to eq(5)
-    expect(@client.fetch_index(@uid5).uid).to eq(index.uid)
-    expect(@client.fetch_index(@uid5).uid).to eq(@uid5)
-    expect(@client.fetch_index(@uid5).primary_key).to eq('title')
-    expect(@client.fetch_index(@uid5).primary_key).to eq(index.primary_key)
+    client.create_index(test_uid)
+
+    expect do
+      index = client.get_or_create_index(test_uid)
+
+      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 })
   end
 
   it 'fails to create an index with an uid already taken' do
+    client.create_index(test_uid)
+
     expect do
-      @client.create_index(@uid1)
+      client.create_index(test_uid)
     end.to raise_meilisearch_api_error_with(400, 'index_already_exists', 'invalid_request_error')
   end
 
   it 'fails to create an index with bad UID format' do
     expect do
-      @client.create_index('two words')
+      client.create_index('two words')
     end.to raise_meilisearch_api_error_with(400, 'invalid_index_uid', 'invalid_request_error')
   end
 
   it 'gets list of indexes' do
-    response = @client.indexes
-    expect(response).to be_a(Array)
-    expect(response.count).to eq(5)
-    uids = response.map { |elem| elem['uid'] }
-    expect(uids).to contain_exactly(@uid1, @uid2, @uid3, @uid4, @uid5)
+    ['first_index', 'second_index', 'third_index'].each { |name| client.create_index(name) }
+
+    indexes = client.indexes
+
+    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
 
   it 'fetch a specific index' do
-    response = @client.fetch_index(@uid2)
+    client.create_index('specific_index', primaryKey: 'primary_key')
+
+    response = client.fetch_index('specific_index')
+
     expect(response).to be_a(MeiliSearch::Index)
-    expect(response.uid).to eq(@uid2)
-    expect(response.primary_key).to eq(@primary_key)
-    expect(response.fetch_primary_key).to eq(@primary_key)
+    expect(response.uid).to eq('specific_index')
+    expect(response.primary_key).to eq('primary_key')
+    expect(response.fetch_primary_key).to eq('primary_key')
   end
 
   it 'returns an index object based on uid' do
-    index = @client.index(@uid2)
+    client.create_index('index_with_pk', primaryKey: 'primary_key')
+
+    index = client.index('index_with_pk')
+
     expect(index).to be_a(MeiliSearch::Index)
-    expect(index.uid).to eq(@uid2)
+    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(index.fetch_primary_key).to eq('primary_key')
+    expect(index.primary_key).to eq('primary_key')
   end
 
-  it 'deletes index' do
-    expect(@client.delete_index(@uid1)).to be_nil
-    expect { @client.fetch_index(@uid1) }.to raise_index_not_found_meilisearch_api_error
-    expect(@client.delete_index(@uid2)).to be_nil
-    expect { @client.fetch_index(@uid2) }.to raise_index_not_found_meilisearch_api_error
-    expect(@client.delete_index(@uid3)).to be_nil
-    expect { @client.fetch_index(@uid3) }.to raise_index_not_found_meilisearch_api_error
-    expect(@client.delete_index(@uid4)).to be_nil
-    expect { @client.fetch_index(@uid4) }.to raise_index_not_found_meilisearch_api_error
-    expect(@client.delete_index(@uid5)).to be_nil
-    expect { @client.fetch_index(@uid5) }.to raise_index_not_found_meilisearch_api_error
-    expect(@client.indexes.count).to eq(0)
-  end
+  it 'deletes an index' do
+    client.create_index('index')
 
-  it 'deletes index if index exists' do
-    @client.create_index(@uid6)
-    expect(@client.delete_index_if_exists(@uid6)).to eq(true)
-    expect { @client.fetch_index(@uid6) }.to raise_index_not_found_meilisearch_api_error
-    expect(@client.delete_index_if_exists(@uid6)).to eq(false)
-    expect(@client.indexes.count).to eq(0)
+    expect do
+      expect(client.delete_index('index')).to be_nil
+    end.to(change { client.indexes.length }.by(-1))
   end
 
   context 'with snake_case options' do
     it 'creates an index without errors' do
       uid = SecureRandom.uuid
 
       expect do
-        @client.create_index(uid, primary_key: @primary_key)
-        @client.fetch_index(uid)
+        client.create_index(uid, primary_key: @primary_key)
+        client.fetch_index(uid)
       end.to_not raise_error
     end
   end

spec/meilisearch/client/keys_spec.rb

@@ -1,16 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe 'MeiliSearch::Client - Keys' do
-  before(:all) do
-    @client = MeiliSearch::Client.new(URL, MASTER_KEY)
-    @uid = 'uid'
-    @client.create_index(@uid)
-  end
-
-  after(:all) { clear_all_indexes(@client) }
-
   it 'gets the list of keys' do
-    response = @client.keys
+    response = client.keys
     expect(response).to be_a(Hash)
     expect(response.count).to eq(2)
     expect(response.keys).to contain_exactly('private', 'public')
@@ -19,15 +11,15 @@
   end
 
   it 'fails to get settings if public key used' do
-    public_key = @client.keys['public']
+    public_key = client.keys['public']
     new_client = MeiliSearch::Client.new(URL, public_key)
     expect do
-      new_client.index(@uid).settings
+      new_client.index(test_uid).settings
     end.to raise_meilisearch_api_error_with(403, 'invalid_token', 'authentication_error')
   end
 
   it 'fails to get keys if private key used' do
-    private_key = @client.keys['private']
+    private_key = client.keys['private']
     new_client = MeiliSearch::Client.new(URL, private_key)
     expect do
       new_client.keys
@@ -37,25 +29,30 @@
   it 'fails to search if no key used' do
     new_client = MeiliSearch::Client.new(URL)
     expect do
-      new_client.index(@uid).settings
+      new_client.index(test_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
-    public_key = @client.keys['public']
+    public_key = client.keys['public']
+    index = client.create_index(test_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(@uid).search('test')
+    response = new_client.index(test_uid).search('test')
     expect(response).to have_key('hits')
   end
 
   it 'succeeds to get settings when using private key' do
-    private_key = @client.keys['private']
+    client.create_index(test_uid)
+    private_key = client.keys['private']
     new_client = MeiliSearch::Client.new(URL, private_key)
-    response = new_client.index(@uid).settings
+    response = new_client.index(test_uid).settings
     expect(response).to have_key('rankingRules')
   end
 
   it 'works with method aliases' do
-    expect(@client.method(:keys) == @client.method(:get_keys)).to be_truthy
+    expect(client.method(:keys) == client.method(:get_keys)).to be_truthy
   end
 end

spec/meilisearch/client/stats_spec.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
 RSpec.describe 'MeiliSearch::Client - Stats' do
-  before(:all) do
-    @client = MeiliSearch::Client.new(URL, MASTER_KEY)
-  end
-
   it 'gets version' do
-    response = @client.version
+    response = client.version
     expect(response).to be_a(Hash)
     expect(response).to have_key('commitSha')
     expect(response).to have_key('commitDate')
     expect(response).to have_key('pkgVersion')
   end
 
   it 'gets stats' do
-    response = @client.stats
+    response = client.stats
     expect(response).to have_key('databaseSize')
   end
 end