Add API keys methods (#279)

* Add API keys methods

* Fix linter errors

Author: curquiza

lib/meilisearch/client.rb

@@ -55,7 +55,26 @@ def fetch_raw_index(index_uid)
     def keys
       http_get '/keys'
     end
-    alias get_keys keys
+
+    def key(key_uid)
+      http_get "/keys/#{key_uid}"
+    end
+
+    def create_key(key_options)
+      body = Utils.transform_attributes(key_options)
+
+      http_post '/keys', body
+    end
+
+    def update_key(key_uid, key_options)
+      body = Utils.transform_attributes(key_options)
+
+      http_patch "/keys/#{key_uid}", body
+    end
+
+    def delete_key(key_uid)
+      http_delete "/keys/#{key_uid}"
+    end
 
     ### HEALTH
 

lib/meilisearch/http_request.rb

@@ -49,6 +49,16 @@ def http_put(relative_path = '', body = nil, query_params = nil)
       )
     end
 
+    def http_patch(relative_path = '', body = nil, query_params = nil)
+      send_request(
+        proc { |path, config| self.class.patch(path, config) },
+        relative_path,
+        query_params: query_params,
+        body: body,
+        options: @options
+      )
+    end
+
     def http_delete(relative_path = '')
       send_request(
         proc { |path, config| self.class.delete(path, config) },
@@ -60,10 +70,11 @@ def http_delete(relative_path = '')
     private
 
     def build_default_options_headers(api_key = nil)
-      {
-        'Content-Type' => 'application/json',
-        'Authorization' => "Bearer #{api_key}"
-      }.compact
+      header = {
+        'Content-Type' => 'application/json'
+      }
+      header = header.merge('Authorization' => "Bearer #{api_key}") unless api_key.nil?
+      header
     end
 
     def merge_options(default_options, added_options = {})

spec/meilisearch/client/keys_spec.rb

@@ -1,59 +1,143 @@
 # frozen_string_literal: true
 
 RSpec.describe 'MeiliSearch::Client - Keys' do
-  it 'gets the list of keys' do
-    response = client.keys
-    expect(response).to be_a(Hash)
-    expect(response.count).to eq(2)
-    expect(response.keys).to contain_exactly('private', 'public')
-    expect(response['private']).to be_a(String)
-    expect(response['public']).to be_a(String)
-  end
+  context 'Test the default key roles' do
+    let(:public_key) { client.keys.filter { |k| k['description'].start_with? 'Default Search API Key' }.first }
+    let(:private_key) { client.keys.filter { |k| k['description'].start_with? 'Default Admin API Key' }.first }
 
-  it 'fails to get settings if public key used' do
-    public_key = client.keys['public']
-    new_client = MeiliSearch::Client.new(URL, public_key)
-    expect do
-      new_client.index(random_uid).settings
-    end.to raise_meilisearch_api_error_with(403, 'invalid_api_key', 'auth')
-  end
+    it 'fails to get settings if public key used' do
+      new_client = MeiliSearch::Client.new(URL, public_key['key'])
+      expect do
+        new_client.index(random_uid).settings
+      end.to raise_meilisearch_api_error_with(403, 'invalid_api_key', 'auth')
+    end
 
-  it 'fails to get keys if private key used' do
-    private_key = client.keys['private']
-    new_client = MeiliSearch::Client.new(URL, private_key)
-    expect do
-      new_client.keys
-    end.to raise_meilisearch_api_error_with(403, 'invalid_api_key', 'auth')
-  end
+    it 'fails to get keys if private key used' do
+      new_client = MeiliSearch::Client.new(URL, private_key['key'])
+      expect do
+        new_client.keys
+      end.to raise_meilisearch_api_error_with(403, 'invalid_api_key', 'auth')
+    end
 
-  it 'fails to search if no key used' do
-    new_client = MeiliSearch::Client.new(URL)
-    expect do
-      new_client.index(random_uid).settings
-    end.to raise_meilisearch_api_error_with(401, 'missing_authorization_header', 'auth')
-  end
+    it 'fails to search if no key used' do
+      new_client = MeiliSearch::Client.new(URL)
+      expect do
+        new_client.index(random_uid).settings
+      end.to raise_meilisearch_api_error_with(401, 'missing_authorization_header', 'auth')
+    end
 
-  it 'succeeds to search when using public key' do
-    uid = random_uid
-    public_key = client.keys['public']
-    index = client.index(uid)
-    index.add_documents!(title: 'Test')
+    it 'succeeds to search when using public key' do
+      uid = random_uid
+      index = client.index(uid)
+      index.add_documents!(title: 'Test')
 
-    new_client = MeiliSearch::Client.new(URL, public_key)
-    response = new_client.index(uid).search('test')
-    expect(response).to have_key('hits')
-  end
+      new_client = MeiliSearch::Client.new(URL, public_key['key'])
+      response = new_client.index(uid).search('test')
+      expect(response).to have_key('hits')
+    end
 
-  it 'succeeds to get settings when using private key' do
-    uid = random_uid
-    client.create_index!(uid)
-    private_key = client.keys['private']
-    new_client = MeiliSearch::Client.new(URL, private_key)
-    response = new_client.index(uid).settings
-    expect(response).to have_key('rankingRules')
+    it 'succeeds to get settings when using private key' do
+      uid = random_uid
+      client.create_index!(uid)
+      new_client = MeiliSearch::Client.new(URL, private_key['key'])
+      response = new_client.index(uid).settings
+      expect(response).to have_key('rankingRules')
+    end
   end
 
-  it 'works with method aliases' do
-    expect(client.method(:keys) == client.method(:get_keys)).to be_truthy
+  context 'Test the key managements' do
+    it 'gets the list of the default keys' do
+      response = client.keys
+      expect(response).to be_a(Array)
+      expect(response.count).to be >= 2
+    end
+
+    it 'creates a key' do
+      key_options = {
+        description: 'A new key to add docs',
+        actions: ['documents.add'],
+        indexes: ['*'],
+        expiresAt: nil
+      }
+      new_key = client.create_key(key_options)
+      expect(new_key['expiresAt']).to be_nil
+      expect(new_key['key']).to be_a(String)
+      expect(new_key['createdAt']).to be_a(String)
+      expect(new_key['updatedAt']).to be_a(String)
+      expect(new_key['indexes']).to eq(['*'])
+      expect(new_key['description']).to eq('A new key to add docs')
+    end
+
+    it 'creates a key using snake_case' do
+      key_options = {
+        description: 'A new key to add docs',
+        actions: ['documents.add'],
+        indexes: ['*'],
+        expires_at: nil
+      }
+      new_key = client.create_key(key_options)
+      expect(new_key['expiresAt']).to be_nil
+      expect(new_key['key']).to be_a(String)
+      expect(new_key['createdAt']).to be_a(String)
+      expect(new_key['updatedAt']).to be_a(String)
+      expect(new_key['indexes']).to eq(['*'])
+      expect(new_key['description']).to eq('A new key to add docs')
+    end
+
+    it 'gets a key' do
+      key_options = {
+        description: 'A new key to delete docs',
+        actions: ['documents.delete'],
+        indexes: ['*'],
+        expiresAt: nil
+      }
+      new_key = client.create_key(key_options)
+      expect(client.key(new_key['key'])['description']).to eq('A new key to delete docs')
+    end
+
+    it 'update a key' do
+      key_options = {
+        description: 'A new key to delete docs',
+        actions: ['documents.delete'],
+        indexes: ['*'],
+        expiresAt: nil
+      }
+      new_key = client.create_key(key_options)
+
+      new_updated_key = client.update_key(new_key['key'], indexes: ['coco'])
+
+      expect(new_updated_key['key']).to eq(new_key['key'])
+      expect(new_updated_key['description']).to eq(new_key['description'])
+      expect(new_updated_key['indexes']).to eq(['coco'])
+    end
+
+    it 'update a key using snake_case' do
+      key_options = {
+        description: 'A new key to delete docs',
+        actions: ['documents.delete'],
+        indexes: ['*'],
+        expires_at: nil
+      }
+      new_key = client.create_key(key_options)
+
+      new_updated_key = client.update_key(new_key['key'], indexes: ['coco'])
+
+      expect(new_updated_key['key']).to eq(new_key['key'])
+      expect(new_updated_key['description']).to eq(new_key['description'])
+      expect(new_updated_key['indexes']).to eq(['coco'])
+    end
+
+    it 'deletes a key' do
+      key_options = {
+        description: 'A new key to add docs',
+        actions: ['documents.add'],
+        indexes: ['*'],
+        expiresAt: nil
+      }
+      new_key = client.create_key(key_options)
+
+      client.delete_key(new_key['key'])
+      expect(client.keys.filter { |k| k['key'] == new_key['key'] }).to be_empty
+    end
   end
 end