gitlab_quality-test_tooling 2.19.1 → 2.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e14c5a03000218d4c10afb6d388605dac227ab1f436089e40239e87329b66d17
-  data.tar.gz: 499608ec04650db2746fa234c996c4b37c8fb99a544dbcf3fdb8d2de5768445e
+  metadata.gz: c9587ce85da22ee8e77100c3f46e7d46e9bdfe82f129b8de757af427073b51f2
+  data.tar.gz: 38318dc4c100c8bd8ba2bbbaa66e1551ce99b12214566d667e822d99eee667ca
 SHA512:
-  metadata.gz: 1022bde869ad7de0c7dabc0f1b2084518616ef6987a22593948351f1a2924b8d9532ac9979adee193acaf1a279c1e4f8a197e7b1d60bbee8d884a76f19116d7b
-  data.tar.gz: 5fc60b6d49fd488f6007a11b585b8c32ccdb224b7b18be44cd559b708353fc42b9c8538234dc235859eb09492c9f336144efc6ac8b8a2dd909ab58b41cbe1386
+  metadata.gz: bb75f7abc4c94f6e21d58f4af282763dfe5f671e4f94dae194d99f616a276d5958e6c9ffc3af04d92bc4146cbac02194e9444af9205d213a817a035d90b07c8e
+  data.tar.gz: '036382fbbdd1f85e5f01528b8c74214b2eab236519d8b174a7c71b53662896f996a3a0d7a91e21b5afe46494823aa17379a9c2044e769a0413d93626082cdc5c'

data/.ruby-version

@@ -1 +1 @@
-3.2.5
+3.3.9

data/.tool-versions

@@ -1,2 +1,2 @@
-ruby 3.2.5
+ruby 3.3.9
 lefthook 1.7.14

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab_quality-test_tooling (2.19.1)
+    gitlab_quality-test_tooling (2.20.1)
       activesupport (>= 7.0, < 7.3)
       amatch (~> 0.4.1)
       fog-google (~> 1.24, >= 1.24.1)
@@ -128,13 +128,15 @@ GEM
       danger (>= 8.4.5)
       danger-gitlab (>= 8.0.0)
       rake
-    gitlab-styles (12.0.1)
-      rubocop (~> 1.62.1)
-      rubocop-factory_bot (~> 2.25.1)
-      rubocop-graphql (~> 1.5.0)
-      rubocop-performance (~> 1.20.2)
-      rubocop-rails (~> 2.24.0)
-      rubocop-rspec (~> 2.27.1)
+    gitlab-styles (13.1.0)
+      rubocop (= 1.71.1)
+      rubocop-capybara (~> 2.21.0)
+      rubocop-factory_bot (~> 2.26.1)
+      rubocop-graphql (~> 1.5.4)
+      rubocop-performance (~> 1.21.1)
+      rubocop-rails (~> 2.26.0)
+      rubocop-rspec (~> 3.0.4)
+      rubocop-rspec_rails (~> 2.30.0)
     google-apis-compute_v1 (0.108.0)
       google-apis-core (>= 0.15.0, < 2.a)
     google-apis-core (0.15.1)
@@ -262,7 +264,7 @@ GEM
       pry (>= 0.13, < 0.15)
     public_suffix (6.0.1)
     racc (1.8.1)
-    rack (3.1.7)
+    rack (3.2.1)
     rainbow (3.1.1)
     rake (13.2.1)
     rb-fsevent (0.11.2)
@@ -270,7 +272,7 @@ GEM
       ffi (~> 1.0)
     rbs (2.8.4)
     rchardet (1.8.0)
-    regexp_parser (2.9.2)
+    regexp_parser (2.11.2)
     representable (3.2.0)
       declarative (< 0.1.0)
       trailblazer-option (>= 0.1.1, < 0.2.0)
@@ -311,37 +313,37 @@ GEM
     rspec-support (3.13.1)
     rspec_junit_formatter (0.6.0)
       rspec-core (>= 2, < 4, != 2.12.0)
-    rubocop (1.62.1)
+    rubocop (1.71.1)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.31.1, < 2.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.32.3)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.40.0)
       parser (>= 3.3.1.0)
     rubocop-capybara (2.21.0)
       rubocop (~> 1.41)
-    rubocop-factory_bot (2.25.1)
-      rubocop (~> 1.41)
+    rubocop-factory_bot (2.26.1)
+      rubocop (~> 1.61)
     rubocop-graphql (1.5.4)
       rubocop (>= 1.50, < 2)
-    rubocop-performance (1.20.2)
+    rubocop-performance (1.21.1)
       rubocop (>= 1.48.1, < 2.0)
-      rubocop-ast (>= 1.30.0, < 2.0)
-    rubocop-rails (2.24.1)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    rubocop-rails (2.26.2)
       activesupport (>= 4.2.0)
       rack (>= 1.1)
-      rubocop (>= 1.33.0, < 2.0)
+      rubocop (>= 1.52.0, < 2.0)
       rubocop-ast (>= 1.31.1, < 2.0)
-    rubocop-rspec (2.27.1)
-      rubocop (~> 1.40)
-      rubocop-capybara (~> 2.17)
-      rubocop-factory_bot (~> 2.22)
+    rubocop-rspec (3.0.5)
+      rubocop (~> 1.61)
+    rubocop-rspec_rails (2.30.0)
+      rubocop (~> 1.61)
+      rubocop-rspec (~> 3, >= 3.0.1)
     ruby-progressbar (1.13.0)
     sawyer (0.9.2)
       addressable (>= 2.3.5)
@@ -409,7 +411,7 @@ PLATFORMS
 DEPENDENCIES
   climate_control (~> 1.2)
   gitlab-dangerfiles (~> 3.8)
-  gitlab-styles (~> 12.0)
+  gitlab-styles (~> 13.1)
   gitlab_quality-test_tooling!
   guard-rspec (~> 4.7)
   lefthook (~> 1.3)
@@ -425,4 +427,4 @@ DEPENDENCIES
   webmock (= 3.7.0)
 
 BUNDLED WITH
-   2.5.19
+   2.7.2

data/exe/epic-readiness-notification

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "optparse"
+require 'active_support/core_ext/hash'
+
+require_relative "../lib/gitlab_quality/test_tooling"
+params = {}
+
+options = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
+
+  opts.on('-u', '--epic-urls URLS', String, 'Comma-separated list of epic URLs') do |urls|
+    params[:epic_urls] = urls.split(',').map(&:strip)
+  end
+
+  opts.on('-f', '--epic-urls-file FILE', String, 'File containing epic URLs (one per line)') do |file|
+    params[:epic_urls_file] = file
+  end
+
+  opts.on('-t', '--token TOKEN', String, 'A valid access token with `api` scope and appropriate permissions') do |token|
+    params[:token] = token
+  end
+
+  opts.on('-m', '--message MESSAGE', String, 'Custom message template (optional)') do |message|
+    params[:message] = message
+  end
+
+  opts.on('--dry-run', "Perform a dry-run (don't post comments)") do
+    params[:dry_run] = true
+  end
+
+  opts.on_tail('-v', '--version', 'Show the version') do
+    require_relative "../lib/gitlab_quality/test_tooling/version"
+    puts "#{$PROGRAM_NAME} : #{GitlabQuality::TestTooling::VERSION}"
+    exit
+  end
+
+  opts.on_tail('-h', '--help', 'Show the usage') do
+    puts "Purpose: Send feature readiness assessment notifications to epic authors via @mentions"
+    puts opts
+    exit
+  end
+
+  opts.parse(ARGV)
+end
+
+# Validate required arguments
+raise ArgumentError, "Missing required argument: --token" unless params[:token]
+raise ArgumentError, "Must provide either --epic-urls or --epic-urls-file" unless params[:epic_urls] || params[:epic_urls_file]
+
+if params.any?
+  GitlabQuality::TestTooling::FeatureReadiness::EpicReadinessNotifier.new(**params).invoke!
+else
+  puts options
+  exit 1
+end

data/lib/gitlab_quality/test_tooling/click_house/client.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "json"
+require "logger"
+
+module GitlabQuality
+  module TestTooling
+    module ClickHouse
+      class Client
+        include HTTParty
+
+        DEFAULT_BATCH_SIZE = 100_000
+        LOG_PREFIX = "[ClickHouse]"
+
+        def initialize(url:, database:, username: nil, password: nil, logger: ::Logger.new($stdout, level: 1))
+          @url = url
+          @database = database
+          @username = username
+          @password = password
+          @logger = logger
+
+          # Set base URI
+          self.class.base_uri @url
+
+          # Set basic auth if credentials provided
+          return unless @username && @password
+
+          self.class.basic_auth @username, @password
+        end
+
+        # Push data to ClickHouse
+        #
+        # @param table_name [String]
+        # @param data [Array<Hash>]
+        # @param batch_size [Integer]
+        # @return [void]
+        def insert_json_data(table_name, data, batch_size: DEFAULT_BATCH_SIZE) # rubocop:disable Metrics/AbcSize
+          raise ArgumentError, "Expected data to be an Array, got #{data.class}" unless data.is_a?(Array)
+          raise ArgumentError, "Expected all elements of array to be hashes" unless data.is_a?(Array) && data.all?(Hash)
+          raise ArgumentError, "Expected data to not be empty" if data.empty?
+
+          total_batches = (data.size.to_f / batch_size).ceil
+          results = data.each_slice(batch_size).with_index.map do |batch, index|
+            logger.debug("#{LOG_PREFIX} Pushing batch #{index + 1} of #{total_batches}")
+            send_batch(table_name, batch)
+          end
+          logger.debug("#{LOG_PREFIX} Processed #{results.size} result batches")
+          return if results.all? { |res| res[:success] }
+
+          err = results
+            .reject { |res| res[:success] }
+            .map { |res| "size: #{res[:count]}, err: #{res[:error]}" }
+            .join("\n")
+          raise "Failures detected when pushing data to ClickHouse, errors:\n#{err}"
+        end
+
+        private
+
+        attr_reader :logger
+
+        # Push batch of data
+        #
+        # @param table_name [String] table name
+        # @param batch [Array<Hash>] data batch
+        # @return [Hash]
+        def send_batch(table_name, batch)
+          response = self.class.post('/', {
+            body: batch.map(&:to_json).join("\n"),
+            headers: { 'Content-Type' => 'application/json' },
+            query: {
+              database: @database,
+              query: "INSERT INTO #{table_name} FORMAT JSONEachRow"
+            }
+          })
+          return { success: true, count: batch.size, response: response.body } if response.code == 200
+
+          { success: false, count: batch.size, error: response.body }
+        rescue StandardError => e
+          { success: false, count: batch.size, error: e.message }
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/feature_readiness/concerns/issue_concern.rb

@@ -21,7 +21,7 @@ module GitlabQuality
           end
 
           def has_operational_readiness_issue_linked?(linked_issue_iids, issue_client)
-            linked_issues(linked_issue_iids, issue_client).any? { |issue| (issue.labels & [OPERATIONAL_READINESS_CHECKLIST_LABEL]).any? }
+            linked_issues(linked_issue_iids, issue_client).any? { |issue| issue.labels.intersect?([OPERATIONAL_READINESS_CHECKLIST_LABEL]) }
           end
 
           def linked_issues(linked_issue_iids, issue_client)

data/lib/gitlab_quality/test_tooling/feature_readiness/concerns/work_item_concern.rb

@@ -118,6 +118,17 @@ module GitlabQuality
             labels.first.id
           end
 
+          def ids_for_group_labels(labels, group_labels_client)
+            labels.filter_map { |label| get_id_for_group_label(label, group_labels_client) }
+          end
+
+          def get_id_for_group_label(label_name, group_labels_client)
+            labels = group_labels_client.group_labels(options: { search: label_name })
+            return nil if labels.empty?
+
+            labels.first.id
+          end
+
           def extract_id_from_gid(gid)
             gid.to_s.split('/').last.to_i
           end

data/lib/gitlab_quality/test_tooling/feature_readiness/epic_readiness_notifier.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module GitlabQuality
+  module TestTooling
+    module FeatureReadiness
+      class EpicReadinessNotifier
+        include Concerns::WorkItemConcern
+
+        FEATURE_READINESS_NOTIFICATION_ID = '<!-- FEATURE READINESS NOTIFICATION -->'
+        FEATURE_READINESS_CANDIDATE_LABEL = 'feature readiness candidate'
+
+        def initialize(token:, epic_urls: nil, epic_urls_file: nil, message: nil, dry_run: false)
+          @token = token
+          @epic_urls = epic_urls
+          @epic_urls_file = epic_urls_file
+          @custom_message = message
+          @dry_run = dry_run
+          @results = []
+        end
+
+        def invoke!
+          urls = collect_epic_urls
+          print_header(urls.size)
+          process_all_urls(urls)
+          print_summary
+        end
+
+        private
+
+        attr_reader :token, :epic_urls, :epic_urls_file, :custom_message, :dry_run, :results
+
+        def print_header(url_count)
+          puts "Processing #{url_count} epic URL(s)..."
+          puts "Dry run mode: #{dry_run ? 'enabled' : 'disabled'}"
+          puts
+        end
+
+        def process_all_urls(urls)
+          urls.each_with_index do |url, index|
+            puts "[#{index + 1}/#{urls.size}] Processing: #{url}"
+            process_single_url(url)
+            puts
+          end
+        end
+
+        def process_single_url(url)
+          result = process_epic_url(url)
+          @results << result
+          print_result(result)
+        rescue StandardError => e
+          error_result = { url: url, success: false, error: e.message }
+          @results << error_result
+          puts "  ❌ Error: #{e.message}"
+        end
+
+        def print_result(result)
+          if result[:success]
+            author_info = result[:author] ? (result[:author]).to_s : "epic (no author assigned)"
+            puts "  ✅ Successfully notified #{author_info} and added label '#{FEATURE_READINESS_CANDIDATE_LABEL}' to epic: #{result[:title]}"
+          else
+            puts "  ❌ Failed: #{result[:error]}"
+          end
+        end
+
+        def collect_epic_urls
+          urls = []
+          urls.concat(epic_urls) if epic_urls
+          urls.concat(collect_urls_from_file) if epic_urls_file
+          validate_urls_present(urls)
+          urls.uniq
+        end
+
+        def collect_urls_from_file
+          validate_file_exists
+          File.readlines(epic_urls_file, chomp: true)
+              .map(&:strip)
+              .reject(&:empty?)
+              .reject { |line| line.start_with?('#') }
+        end
+
+        def validate_file_exists
+          return if File.exist?(epic_urls_file)
+
+          raise ArgumentError, "Epic URLs file not found: #{epic_urls_file}"
+        end
+
+        def validate_urls_present(urls)
+          return unless urls.empty?
+
+          raise ArgumentError, "No epic URLs provided"
+        end
+
+        def process_epic_url(url)
+          epic_info = parse_epic_url(url)
+          client = work_items_client_for_group(epic_info[:group])
+          epic = fetch_and_validate_epic(epic_info, client, url)
+
+          return epic if epic.key?(:error)
+
+          existing_note = existing_note_containing_text(FEATURE_READINESS_NOTIFICATION_ID, epic_info[:epic_iid], client)
+          return build_existing_notification_result(url, epic) if existing_note
+
+          post_notification_and_label(epic, epic_info, client) unless dry_run
+          build_success_result(url, epic, epic_info)
+        end
+
+        def fetch_and_validate_epic(epic_info, client, url)
+          epic = fetch_work_item(epic_info[:epic_iid], client, [:notes])
+          return { url: url, success: false, error: "Epic not found or not accessible" } unless epic
+          return { url: url, success: false, error: "Work item is not an epic (type: #{epic[:workItemType][:name]})" } unless epic[:workItemType][:name] == "Epic"
+
+          epic
+        end
+
+        def build_existing_notification_result(url, epic)
+          {
+            url: url,
+            success: false,
+            error: "Notification already exists",
+            title: epic[:title],
+            author: epic[:author] ? epic[:author][:username] : nil
+          }
+        end
+
+        def post_notification_and_label(epic, epic_info, client)
+          message = build_notification_message(epic)
+
+          # Create the discussion/comment
+          client.post(
+            <<~GQL
+              mutation CreateDiscussion {
+                  createDiscussion(input: {noteableId: "#{epic[:id]}", body: #{message.inspect}}) {
+                      clientMutationId
+                      errors
+                      note {
+                          id
+                          body
+                      }
+                  }
+              }
+            GQL
+          )
+
+          # Apply group label if it exists
+          apply_group_label_if_exists(epic, epic_info, client)
+        end
+
+        def build_success_result(url, epic, epic_info)
+          {
+            url: url,
+            success: true,
+            title: epic[:title],
+            author: epic[:author] ? epic[:author][:username] : nil,
+            group: epic_info[:group],
+            epic_iid: epic_info[:epic_iid]
+          }
+        end
+
+        def parse_epic_url(url)
+          uri = URI.parse(url)
+          path_parts = uri.path.split('/')
+          groups_index, epics_index = find_url_indices(path_parts, url)
+          group_path, epic_iid = extract_group_and_epic_id(path_parts, groups_index, epics_index, url)
+
+          {
+            host: "#{uri.scheme}://#{uri.host}",
+            group: group_path,
+            epic_iid: epic_iid,
+            url: url
+          }
+        end
+
+        def find_url_indices(path_parts, url)
+          groups_index = path_parts.index('groups')
+          epics_index = path_parts.index('epics')
+
+          raise ArgumentError, "Invalid epic URL format: #{url}" unless groups_index && epics_index && epics_index > groups_index
+
+          [groups_index, epics_index]
+        end
+
+        def extract_group_and_epic_id(path_parts, groups_index, epics_index, url)
+          group_parts = path_parts[(groups_index + 1)...(epics_index - 1)]
+          group_path = group_parts.join('/')
+          epic_iid = path_parts[epics_index + 1]
+
+          validate_extracted_parts(group_path, epic_iid, url)
+          [group_path, epic_iid]
+        end
+
+        def validate_extracted_parts(group_path, epic_iid, url)
+          return if group_path && epic_iid&.match?(/^\d+$/)
+
+          raise ArgumentError, "Could not extract group and epic IID from URL: #{url}"
+        end
+
+        def work_items_client_for_group(group)
+          client_class = dry_run ? GitlabClient::WorkItemsDryClient : GitlabClient::WorkItemsClient
+          client_class.new(token: token, project: nil, group: group)
+        end
+
+        def group_labels_client_for_group(group)
+          GitlabClient::GroupLabelsClient.new(token: token, group: group)
+        end
+
+        def apply_group_label_if_exists(epic, epic_info, client)
+          group_labels_client = group_labels_client_for_group(epic_info[:group])
+          label_ids = ids_for_group_labels([FEATURE_READINESS_CANDIDATE_LABEL], group_labels_client)
+
+          if label_ids.empty?
+            puts "Warning: Group label '#{FEATURE_READINESS_CANDIDATE_LABEL}' not found in group #{epic_info[:group]}. Skipping label application."
+            return
+          end
+
+          puts "Applying group label '#{FEATURE_READINESS_CANDIDATE_LABEL}' to epic..." unless dry_run
+          add_labels(label_ids, epic[:id], client) unless dry_run
+        rescue StandardError => e
+          puts "Warning: Could not apply group label '#{FEATURE_READINESS_CANDIDATE_LABEL}': #{e.message}"
+        end
+
+        def build_notification_message(epic)
+          author_mention = build_author_mention(epic)
+
+          message = custom_message || default_message_template
+
+          # Replace placeholders in the message
+          message = message.gsub('{author}', author_mention)
+                          .gsub('{epic_title}', epic[:title])
+                          .gsub('{epic_url}', epic[:webUrl])
+
+          # Add the notification ID for tracking
+          "#{FEATURE_READINESS_NOTIFICATION_ID}\n#{message}"
+        end
+
+        def build_author_mention(epic)
+          return '' unless epic[:author] && epic[:author][:username]
+
+          "@#{epic[:author][:username]}"
+        end
+
+        def default_message_template
+          <<~MESSAGE
+            ### Platform Readiness Enablement Process (PREP) Potentially Required
+
+            {author} The feature **"{epic_title}"** has been selected as a potential candidate for Platform Readiness Enablement Process.
+
+            ### What is PREP?
+            The **Platform Readiness Enablement Process** (PREP) is a comprehensive process
+            that guides product teams through evaluating GitLab features for readiness
+            across GitLab.com, GitLab Dedicated, and GitLab Self-Managed deployment platforms.
+
+            Please note that a completed and approved PREP is **mandatory** for qualified features to reach GA status.
+
+            ## Next Steps:
+             1. Review the [handbook](https://internal.gitlab.com/handbook/product/platforms/feature-readiness-assessment/#when-prep-is-required) to confirm if you feature qualifies for PREP.
+             2. If it does, start the assessment by following the guidelines in the [documentation](https://gitlab.com/gitlab-org/architecture/readiness).
+             3. Reach out to the Feature Readiness team on Slack at `#g_feature_readiness` if you have questions.
+
+            Please react with ✅ if this classification is relevant or ❌ if not relevant to help improve our system.
+
+          MESSAGE
+        end
+
+        def print_summary
+          successful, failed = calculate_summary_counts
+          print_summary_header
+          print_summary_stats(successful, failed)
+          print_failed_urls(failed) if failed.positive?
+          print_completion_message
+        end
+
+        def calculate_summary_counts
+          successful = results.count { |r| r[:success] }
+          failed = results.count { |r| !r[:success] }
+          [successful, failed]
+        end
+
+        def print_summary_header
+          puts "=" * 50
+          puts "SUMMARY"
+          puts "=" * 50
+        end
+
+        def print_summary_stats(successful, failed)
+          puts "Total processed: #{results.size}"
+          puts "Successful: #{successful}"
+          puts "Failed: #{failed}"
+        end
+
+        def print_failed_urls(_failed)
+          puts
+          puts "Failed URLs:"
+          results.select { |r| !r[:success] }.each do |result|
+            puts "  - #{result[:url]}: #{result[:error]}"
+          end
+        end
+
+        def print_completion_message
+          puts
+          message = dry_run ? "Dry run completed - no notifications were sent or labels added." : "Notification process completed."
+          puts message
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/gcs_tools.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'fog/google'
+
+module GitlabQuality
+  module TestTooling
+    module GcsTools
+      class GCSMockClient
+        def initialize(*_args, **_kwargs); end
+
+        def put_object(gcs_bucket, filename, data, **_kwargs)
+          Runtime::Logger.info "The #{filename} file would have been pushed to the #{gcs_bucket} bucket, with this content:"
+          Runtime::Logger.info data
+        end
+      end
+
+      class << self
+        # GCS Client
+        #
+        # @param project_id [String]
+        # @param credentials [String]
+        # @return [Fog::Storage::Google]
+        def gcs_client(project_id:, credentials:, dry_run: false)
+          if dry_run
+            GCSMockClient.new
+          else
+            Fog::Storage::Google.new(
+              google_project: project_id || raise("Missing Google project_id"),
+              **gcs_creds(credentials)
+            )
+          end
+        end
+
+        private
+
+        # GCS Credentials
+        #
+        # @param credentials [String]
+        # @return [Hash]
+        def gcs_creds(credentials)
+          json_key = credentials || raise('Missing Google credentials')
+          return { google_json_key_location: json_key } if File.exist?(json_key)
+
+          { google_json_key_string: json_key }
+        end
+      end
+    end
+  end
+end