elasticsearch-api 7.13.3 → 8.14.0

data/spec/elasticsearch/api/utils_spec.rb

@@ -18,19 +18,17 @@
 require 'spec_helper'
 
 describe Elasticsearch::API::Utils do
-
   let(:utils) do
     Class.new { include Elasticsearch::API::Utils }.new
   end
 
   describe '#__escape' do
-
     it 'encodes Unicode characters' do
       expect(utils.__escape('中文')).to eq('%E4%B8%AD%E6%96%87')
     end
 
     it 'encodes special characters' do
-      expect(utils.__escape('foo bar')).to eq('foo+bar')
+      expect(utils.__escape('foo bar')).to eq('foo%20bar')
       expect(utils.__escape('foo/bar')).to eq('foo%2Fbar')
       expect(utils.__escape('foo^bar')).to eq('foo%5Ebar')
     end
@@ -38,22 +36,9 @@ describe Elasticsearch::API::Utils do
     it 'does not encode asterisks' do
       expect(utils.__escape('*')).to eq('*')
     end
-
-    it 'users CGI.escape by default' do
-      expect(CGI).to receive(:escape).and_call_original
-      expect(utils.__escape('foo bar')).to eq('foo+bar')
-    end
-
-    it 'uses the escape_utils gem when available', unless: defined?(JRUBY_VERSION) do
-      require 'escape_utils'
-      expect(CGI).not_to receive(:escape)
-      expect(EscapeUtils).to receive(:escape_url).and_call_original
-      expect(utils.__escape('foo bar')).to eq('foo+bar')
-    end
   end
 
   describe '#__listify' do
-
     it 'creates a list from a single value' do
       expect(utils.__listify('foo')).to eq('foo')
     end
@@ -75,15 +60,13 @@ describe Elasticsearch::API::Utils do
     end
 
     context 'when the escape option is set to false' do
-
       it 'does not escape the characters' do
-        expect(utils.__listify(['foo', 'bar^bam'], :escape => false)).to eq('foo,bar^bam')
+        expect(utils.__listify(['foo', 'bar^bam'], escape: false)).to eq('foo,bar^bam')
       end
     end
   end
 
   describe '#__pathify' do
-
     it 'creates a path from a single value' do
       expect(utils.__pathify('foo')).to eq('foo')
     end
@@ -102,24 +85,22 @@ describe Elasticsearch::API::Utils do
   end
 
   describe '#__bulkify' do
-
     context 'when the input is an array of hashes' do
-
       let(:result) do
         utils.__bulkify [
-          { :index =>  { :_index => 'myindexA', :_type => 'mytype', :_id => '1', :data => { :title => 'Test' } } },
-          { :update => { :_index => 'myindexB', :_type => 'mytype', :_id => '2', :data => { :doc => { :title => 'Update' } } } },
-          { :delete => { :_index => 'myindexC', :_type => 'mytypeC', :_id => '3' } }
+          { index: { _index: 'myindexA', _id: '1', data: { title: 'Test' } } },
+          { update: { _index: 'myindexB', _id: '2', data: { doc: { title: 'Update' } } } },
+          { delete: { _index: 'myindexC', _id: '3' } }
         ]
       end
 
       let(:expected_string) do
         <<-PAYLOAD.gsub(/^\s+/, '')
-                {"index":{"_index":"myindexA","_type":"mytype","_id":"1"}}
+                {"index":{"_index":"myindexA","_id":"1"}}
                 {"title":"Test"}
-                {"update":{"_index":"myindexB","_type":"mytype","_id":"2"}}
+                {"update":{"_index":"myindexB","_id":"2"}}
                 {"doc":{"title":"Update"}}
-                {"delete":{"_index":"myindexC","_type":"mytypeC","_id":"3"}}
+                {"delete":{"_index":"myindexC","_id":"3"}}
         PAYLOAD
       end
 
@@ -192,7 +173,6 @@ describe Elasticsearch::API::Utils do
     end
 
     context 'when the payload has nested :data options' do
-
       let(:data) do
         { data: { a: 'b', data: { c: 'd' } } }
       end
@@ -226,83 +206,28 @@ describe Elasticsearch::API::Utils do
   end
 
   context '#__validate_and_extract_params' do
-
     it 'listify Arrays' do
-      expect(utils.__validate_and_extract_params({ foo: ['a', 'b'] }, [:foo] )).to eq(foo: 'a,b')
+      expect(utils.process_params({ foo: ['a', 'b'] })).to eq(foo: 'a,b')
     end
 
     it 'does not escape the parameters' do
-      expect(utils.__validate_and_extract_params({ foo: ['a.*', 'b.*'] }, [:foo] )).to eq(foo: 'a.*,b.*')
+      expect(utils.process_params({ foo: ['a.*', 'b.*'] })).to eq(foo: 'a.*,b.*')
     end
 
     context 'when the params are valid' do
-
       it 'extracts the valid params from the hash' do
-        expect(utils.__validate_and_extract_params({ foo: 'qux' }, [:foo, :bar]) ).to eq(foo: 'qux')
-      end
-    end
-
-    context 'when the params are invalid' do
-
-      it 'raises an ArgumentError' do
-        expect {
-          utils.__validate_and_extract_params({ foo: 'qux', bam: 'mux' }, [:foo, :bar])
-        }.to raise_exception(ArgumentError)
-      end
-    end
-
-    context 'when COMMON_PARAMS are provided' do
-
-      it 'extracts the params' do
-        expect(utils.__validate_and_extract_params({ index: 'foo'}, [:foo])).to eq({})
-      end
-    end
-
-    context 'when COMMON_QUERY_PARAMS are provided' do
-
-      it 'extracts the params' do
-        expect(utils.__validate_and_extract_params(format: 'yaml')).to eq(format: 'yaml')
-      end
-    end
-
-    context 'when the :skip_paramter_validation option is set' do
-
-      let(:result) do
-        utils.__validate_and_extract_params( { foo: 'q', bam: 'm' }, [:foo, :bar], { skip_parameter_validation: true } )
-      end
-
-      it 'skips parameter validation' do
-        expect(result).to eq(foo: 'q', bam: 'm')
-      end
-    end
-
-    context 'when the module has the setting to skip parameter validation' do
-
-      around do |example|
-        original_value = Elasticsearch::API.settings[:skip_parameter_validation]
-        Elasticsearch::API.settings[:skip_parameter_validation] = true
-        example.run
-        Elasticsearch::API.settings[:skip_parameter_validation] = original_value
-      end
-
-      let(:result) do
-        utils.__validate_and_extract_params( { foo: 'q', bam: 'm' }, [:foo, :bar])
-      end
-
-      it 'applies the module setting' do
-        expect(result).to eq(foo: 'q', bam: 'm')
+        expect(utils.process_params({ foo: 'qux' })).to eq(foo: 'qux')
       end
     end
   end
 
   describe '#__extract_parts' do
-
     it 'extracts parts with true value from a Hash' do
-      expect(utils.__extract_parts({ foo: true, moo: 'blah' }, [:foo, :bar])).to eq(['foo'])
+      expect(utils.__extract_parts({ foo: true, moo: 'blah' })).to eq(['foo', 'blah'])
     end
 
     it 'extracts parts with string value from a Hash' do
-      expect(utils.__extract_parts({ foo: 'qux', moo: 'blah' }, [:foo, :bar])).to eq(['qux'])
+      expect(utils.__extract_parts({ foo: 'qux', moo: 'blah' })).to eq(['qux', 'blah'])
     end
   end
 
@@ -379,7 +304,7 @@ describe Elasticsearch::API::Utils do
       end
 
       let(:unsupported_params) do
-        [ { :foo => { :explanation => 'NOT_SUPPORTED'} }, :moo ]
+        [ { foo: { explanation: 'NOT_SUPPORTED'} }, :moo ]
       end
 
 

data/spec/free/integration/health_spec.rb

@@ -0,0 +1,28 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# TODO: These tests won't be necessary once we migrate to the new YAML tests
+require_relative './spec_helper'
+
+describe "Health basic test" do
+  it 'performs the request' do
+    response = CLIENT.health_report
+    expect(response.status).to eq 200
+    expect(response['cluster_name']).not_to be_nil
+    expect(response.dig('indicators', 'master_is_stable', 'symptom')).to eq 'The cluster has a stable master node'
+    expect(response.dig('indicators', 'master_is_stable', 'status')).to eq 'green'
+  end
+end

data/spec/free/integration/spec_helper.rb

@@ -0,0 +1,28 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+require 'elasticsearch'
+
+host = ENV['TEST_ES_SERVER'] || 'http://localhost:9200'
+raise URI::InvalidURIError unless host =~ /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+
+test_suite = ENV['TEST_SUITE'] || 'free'
+password = ENV['ELASTIC_PASSWORD'] || 'changeme'
+uri = URI.parse(host)
+transport_options = {}
+host = "http://elastic:#{password}@#{uri.host}:#{uri.port}".freeze
+
+CLIENT = Elasticsearch::Client.new(host: host, transport_options: transport_options)

data/spec/platinum/integration/analytics/usage_spec.rb

@@ -0,0 +1,56 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require_relative '../platinum_helper'
+
+describe 'analytics/usage stats API' do
+  let(:index) { 'analytics_test' }
+  before do
+    body = [
+      {"index": {}},
+      {"timestamp": "2017-01-01T05:00:00Z", "s": 1, "v1": 3.1415, "v2": 2.1415, "str": "a"},
+      {"index": {}},
+      {"timestamp": "2017-01-01T05:00:00Z", "s": 2, "v1": 1.0, "v2": 2.0, "str": "a"},
+      {"index": {}},
+      {"timestamp": "2017-01-01T05:00:00Z", "s": 3, "v1": 2.71828, "v2": 3.71828, "str": "b"},
+    ]
+    ADMIN_CLIENT.bulk(body: body, index: index, refresh: true)
+  end
+
+  after do
+    ADMIN_CLIENT.indices.delete(index: index)
+  end
+
+  it 'gets memory for all nodes' do
+    response = ADMIN_CLIENT.xpack.usage
+    expect(response['analytics']['available']).to eq true
+    expect(response['analytics']['enabled']).to eq true
+
+    boxplot_usage = response['analytics']['stats']['boxplot_usage']
+
+    response = ADMIN_CLIENT.search(
+      index: index,
+      body: { size: 0, aggs: { plot: { boxplot: { field: 's' } } } }
+    )
+    expect(response['aggregations']['plot']['q2']).to eq 2.0
+
+    response = ADMIN_CLIENT.xpack.usage
+    expect(response['analytics']['available']).to eq true
+    expect(response['analytics']['enabled']).to eq true
+    expect(response['analytics']['stats']['boxplot_usage']).to be > boxplot_usage
+  end
+end

data/spec/platinum/integration/api_key/admin_user_query_api_keys_spec.rb

@@ -0,0 +1,111 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'base64'
+require_relative '../platinum_helper'
+
+describe 'API keys' do
+  before do
+    ADMIN_CLIENT.security.put_user(
+      username: client_username,
+      body: { password: 'test-password', roles: ['superuser'] }
+    )
+  end
+
+  after do
+    ADMIN_CLIENT.security.delete_user(username: client_username)
+  end
+
+  let(:client_username) { "query_api_keys_#{Time.new.to_i}"}
+  let(:credentials) { Base64.strict_encode64("#{client_username}:test-password") }
+
+  let(:client) do
+    Elasticsearch::Client.new(
+      host: HOST,
+      transport_options: TRANSPORT_OPTIONS.merge(headers: { Authorization: "Basic #{credentials}" })
+    )
+  end
+
+  it 'queries API keys' do
+    key_name_1 = "query-key-1-#{Time.new.to_i}"
+    response = client.security.create_api_key(
+      body: {
+        name: key_name_1,
+        role_descriptors: {},
+        expiration: "1d",
+        metadata: { search: "this" }
+      }
+    )
+    expect(response['name']).to eq key_name_1
+    expect(response['api_key']).not_to be nil
+    api_key_id_1 = response['id']
+
+    key_name_2 = "query-key-2-#{Time.new.to_i}"
+    response = client.security.create_api_key(
+      body: {
+        name: key_name_2,
+        expiration: "2d",
+        role_descriptors: { "role-a" => { "cluster": [ "monitor"] } },
+        metadata: { search: false }
+      }
+    )
+    expect(response['name']).to eq key_name_2
+    expect(response['api_key']).not_to be nil
+    api_key_id_2 = response['id']
+
+    key_name_3 = "query-key-3#{Time.new.to_i}"
+    response = client.security.create_api_key(
+      body: {
+        name: key_name_3,
+        expiration: "3d",
+      }
+    )
+    expect(response['name']).to eq key_name_3
+    expect(response['api_key']).not_to be nil
+    api_key_id_3 = response['id']
+
+    response = client.security.authenticate
+    owner_name = response['username']
+
+    response = client.security.query_api_keys(
+      body: {
+        query: { wildcard: { name: key_name_1 }}
+      }
+    )
+    expect(response['total']).to eq 1
+    expect(response['count']).to eq 1
+    expect(response['api_keys'].first['id']).to eq api_key_id_1
+
+    response = client.security.query_api_keys(
+      body: {
+        query: { wildcard: { name: key_name_2 }}
+      }
+    )
+    expect(response['total']).to eq 1
+    expect(response['count']).to eq 1
+    expect(response['api_keys'].first['id']).to eq api_key_id_2
+
+    response = client.security.query_api_keys(
+      body: {
+        query: { wildcard: { name: key_name_3 }}
+      }
+    )
+    expect(response['total']).to eq 1
+    expect(response['count']).to eq 1
+    expect(response['api_keys'].first['id']).to eq api_key_id_3
+  end
+end

data/spec/platinum/integration/api_key/api_key_admin_user_spec.rb

@@ -0,0 +1,127 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'base64'
+require_relative '../platinum_helper'
+
+describe 'API keys' do
+  before do
+    ADMIN_CLIENT.security.put_user(
+      username: client_username,
+      body: { password: 'test-password', roles: ['superuser'] }
+    )
+  end
+
+  after do
+    ADMIN_CLIENT.security.delete_user(username: client_username)
+  end
+
+  let(:client_username) { "superuser#{Time.now.to_i}"}
+
+  let(:client) do
+    Elasticsearch::Client.new(
+      host: "https://#{HOST_URI.host}:#{HOST_URI.port}",
+      user: client_username,
+      password: 'test-password',
+      transport_options: TRANSPORT_OPTIONS
+    )
+  end
+
+  it 'gets api key (with role descriptors + metadata)' do
+    response = client.security.create_api_key(
+      body: {
+        name: "api-key-role",
+        expiration: "1d",
+        role_descriptors: {
+          'role-a': {
+                      cluster: ["all"],
+                      index: [
+                        {
+                          names: ["index-a"],
+                          privileges: ["read"]
+                        }
+                      ]
+                    }
+        },
+        metadata: {
+          string: "bean",
+          number: 5,
+          boolean: true
+        }
+      }
+    )
+    expect(response['name']).to eq 'api-key-role'
+    expect(response['id']).not_to be nil
+    expect(response['api_key']).not_to be nil
+    expect(response['expiration']).not_to be nil
+    api_key_id = response['id']
+    api_key_name = response['name']
+    credentials = response['encoded']
+
+    response = client.security.authenticate
+    owner_name = response['username']
+
+    response = client.security.get_api_key(id: api_key_id)
+    expect(response['api_keys'].first['id']).to eq api_key_id
+    expect(response['api_keys'].first['name']).to eq api_key_name
+    expect(response['api_keys'].first['username']).to eq owner_name
+    expect(response['api_keys'].first['invalidated']).to eq false
+    expect(response['api_keys'].first['creation']).not_to be nil
+    expect(response['api_keys'].first['metadata']['string']).to eq 'bean'
+    expect(response['api_keys'].first['metadata']['number']).to eq 5
+    expect(response['api_keys'].first['metadata']['boolean']).to eq true
+    expect(response['api_keys'].first['role_descriptors'])
+      .to eq(
+            {
+              'role-a' => {
+                'cluster' => ['all'],
+                'indices' => [
+                  {
+                    'names' => ['index-a'],
+                    'privileges' => ['read'],
+                    'allow_restricted_indices' => false
+                  }
+                ],
+                'applications' => [ ],
+                'run_as' => [ ],
+                'metadata' => { },
+                'transient_metadata' => { 'enabled' => true }
+              }
+            }
+          )
+
+    response = client.security.get_api_key(owner: true)
+    expect(response['api_keys'].length).to eq 1
+    expect(response['api_keys'].first['id']).to eq api_key_id
+    expect(response['api_keys'].first['name']).to eq api_key_name
+    expect(response['api_keys'].first['username']).to eq owner_name
+    expect(response['api_keys'].first['invalidated']).to eq false
+    expect(response['api_keys'].first['creation']).not_to be nil
+
+    client = Elasticsearch::Client.new(
+      host: "https://#{HOST_URI.host}:#{HOST_URI.port}",
+      api_key: credentials,
+      transport_options: TRANSPORT_OPTIONS
+    )
+
+    response = client.security.get_api_key(id: api_key_id)
+    expect(response['api_keys'].length).to eq 1
+    expect(response['api_keys'].first['id']).to eq api_key_id
+    expect(response['api_keys'].first['name']).to eq api_key_name
+    expect(response['api_keys'].first['username']).to eq owner_name
+  end
+end

data/spec/platinum/integration/api_key/api_key_cross_cluster_spec.rb

@@ -0,0 +1,113 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'base64'
+require_relative '../platinum_helper'
+
+describe 'API keys API' do
+  let(:user) { 'admin_user' }
+  let(:password) { 'x-pack-test-password' }
+  before do
+    ADMIN_CLIENT.security.put_role(
+      name: 'admin_role',
+      body: { cluster: ['manage_security'] }
+    )
+    ADMIN_CLIENT.security.put_user(
+      username: user,
+      body: {
+        password: password,
+        roles: ['admin_role'],
+        full_name: 'Admin user'
+      }
+    )
+  end
+
+  after do
+    ADMIN_CLIENT.security.delete_role(name: 'admin_role', ignore: 404)
+    ADMIN_CLIENT.security.delete_user(username: user, ignore: 404)
+  end
+
+  describe 'Cross Cluster API Key' do
+    it 'updates api key' do
+      response = ADMIN_CLIENT.security.create_cross_cluster_api_key(
+        body: {
+          name: 'my-cc-api-key',
+          expiration: '1d',
+          access: {
+            search: [
+              { names: ['logs*'] }
+            ],
+            replication: [
+              {
+                names: ['archive'],
+                allow_restricted_indices: false
+              }
+            ]
+          },
+          metadata: {
+            answer: 42,
+            tag: 'dev'
+          }
+        }
+      )
+      expect(response.status).to eq 200
+      expect(response['name']).to eq 'my-cc-api-key'
+      id = response['id']
+      expect(id).not_to be nil
+      expect(response['api_key']).not_to be nil
+      expect(response['expiration']).not_to be nil
+      credentials = Base64.strict_encode64("#{response['id']}:#{response['api_key']}")
+      expect(credentials).to eq response['encoded']
+
+      new_client = Elasticsearch::Client.new(
+        host: "https://#{HOST_URI.host}:#{HOST_URI.port}",
+        transport_options: TRANSPORT_OPTIONS
+      )
+      expect do
+        new_client.security.authenticate(headers: { authorization: "ApiKey #{credentials}" })
+      end.to raise_error(Elastic::Transport::Transport::Errors::Unauthorized)
+
+      response = ADMIN_CLIENT.security.get_api_key(id: id, with_limited_by: true)
+      expect(response.status).to eq 200
+      api_key = response['api_keys'].first
+      expect(api_key['name']) == 'my-cc-api-key'
+      expect(api_key['type']) == 'cross_cluster'
+      expect(api_key['invalidated']).to be false
+      expect(api_key['metadata']).to eq({'answer' => 42, 'tag' => 'dev'})
+
+      # Tests update cc api_key
+      response = ADMIN_CLIENT.security.update_cross_cluster_api_key(
+        id: id,
+        body: {
+          access: {
+            replication: [{ names: ["archive"] }]
+          },
+          metadata: { "tag": "prod" }
+        }
+      )
+      expect(response['updated']).to be true
+
+      response = ADMIN_CLIENT.security.get_api_key(id: id, with_limited_by: true)
+      expect(response['api_keys'].length).to eq 1
+      api_key = response['api_keys'].first
+      expect(api_key['name']) == 'my-cc-api-key'
+      expect(api_key['type']) == 'cross_cluster'
+      expect(api_key['invalidated']).to be false
+      expect(api_key['metadata']).to eq({'tag' => 'prod'})
+    end
+  end
+end