mongoid 7.5.4 → 7.6.0

data/spec/shared/lib/mrss/release/candidate.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'product_data'
+
+module Mrss
+  module Release
+    class Candidate
+      # Release note section titles, by pr type
+      SECTION_TITLE = {
+        bcbreak: "Breaking Changes",
+        feature: "New Features",
+        bug: "Bug Fixes",
+      }.freeze
+
+      # GitHub labels
+      BCBREAK = 'bcbreak'
+      FEATURE = 'feature'
+      BUG = 'bug'
+      PATCH = 'patch'
+
+      def self.instance
+        @instance ||= new
+
+        yield @instance if block_given?
+
+        @instance
+      end
+
+      def product
+        @product ||= ProductData.new
+      end
+
+      def bump_version
+        product.bump_version(release_type)
+      end
+
+      def bump_version!
+        product.bump_version!(release_type)
+      end
+
+      def branch_name
+        @branch_name ||= "rc-#{product.version}"
+      end
+
+      # return a string of commit names since the last release
+      def pending_changes
+        @changes ||= begin
+                       range = product.tag_exists? ? "#{product.tag_name}.." : ""
+                       `git log --pretty=format:"%s" #{range}`
+                     end
+      end
+
+      # return a list of PR numbers since the last release
+      def pending_pr_numbers
+        @pending_pr_numbers ||= pending_changes.
+          lines.
+          map { |line| line.match(/\(#(\d+)\)$/).then { |m| m && m[1] } }.
+          compact.
+          sort.reverse
+      end
+
+      # return a JSON string of PR data
+      def pending_pr_dump
+        @pending_pr_dump ||= `gh pr list --state all --limit 256 --json number,title,labels,url,body --jq 'map(select([.number] | inside([#{pending_pr_numbers.join(',')}]))) | sort_by(.number)'`
+      end
+
+      # return a list of PR data since the last release
+      def pending_prs
+        @pending_prs ||= JSON.parse(pending_pr_dump)
+      end
+
+      # return a list of pending prs with additional attributes (summary,
+      # short title, jira issue number).
+      def decorated_prs
+        @decorated_prs ||= pending_prs.map do |pr|
+                             jira_issue, pr_title = split_pr_title(pr)
+                             summary = extract_summary(pr)
+                             type = pr_type(pr)
+                             type_code = pr_type_code(type)
+                             patch_flag = pr_patch_flag?(pr)
+
+                             pr.merge('jira' => jira_issue,
+                                      'short-title' => pr_title,
+                                      'summary' => summary,
+                                      'type' => type,
+                                      'type-code' => type_code,
+                                      'patch' => patch_flag)
+                           end
+      end
+
+      # return a hash of decorated prs grouped by :bcbreak, :feature, or :bug
+      def prs_by_type
+        @prs_by_type ||= decorated_prs.group_by { |pr| pr['type'] }
+      end
+
+      # returns 'major', 'minor', or 'patch', depending on the presence of
+      # (respectively) :bcbreak, :feature, or :bug labels.
+      #
+      # If the RELEASE environment variable is set, its value will be used
+      # directly, ignoring whatever PR labels might exist.
+      def release_type
+        @release_type ||= if ENV['RELEASE']
+                            ENV['RELEASE']
+                          elsif prs_by_type[:bcbreak]
+                            'major'
+                          elsif prs_by_type[:feature] && prs_by_type[:feature].any? { |pr| !pr['patch'] }
+                            'minor'
+                          else
+                            'patch'
+                          end
+      end
+
+      # returns the generated release notes as a string
+      def release_notes
+        @release_notes ||= release_notes_intro +
+          %i[ bcbreak feature bug ].
+            flat_map { |type| release_notes_for_type(type) }.join("\n")
+      end
+
+      private
+
+      # returns an array of strings, each string representing a single line
+      # in the release notes for the PR's of the given type.
+      def release_notes_for_type(type)
+        return [] unless prs_by_type[type]
+
+        [].tap do |lines|
+          lines << "\# #{SECTION_TITLE[type]}"
+          lines << ''
+
+          prs = prs_by_type[type]
+          summarized, unsummarized = prs.partition { |pr| pr['summary'] }
+
+          summarized.each do |pr|
+            header = [ '### ' ]
+            header << "[#{pr['jira']}](#{jira_url(pr['jira'])}) " if pr['jira']
+            header << "#{pr['short-title']} ([PR](#{pr['url']}))"
+            lines << header.join
+            lines << ''
+            lines << pr['summary']
+            lines << ''
+          end
+
+          if summarized.any? && unsummarized.any?
+            lines << ''
+            lines << [ '### Other ', SECTION_TITLE[type] ].join
+            lines << ''
+          end
+
+          unsummarized.each do |pr|
+            line = [ '* ' ]
+            line << "[#{pr['jira']}](#{jira_url(pr['jira'])}) " if pr['jira']
+            line << "#{pr['short-title']} ([PR](#{pr['url']}))"
+
+            lines << line.join
+          end
+
+          lines << ''
+        end
+      end
+
+      # returns the URL of for the given jira issue
+      def jira_url(issue)
+        "https://jira.mongodb.org/browse/#{issue}"
+      end
+
+      # assumes a pr title in the format of "JIRA-1234 PR Title (#1234)",
+      # returns a tuple of [ jira-issue, title ], where jira-issue may be
+      # blank (if no jira issue is in the title).
+      def split_pr_title(pr)
+        title = pr['title'].gsub(/\(#\d+\)/, '').strip
+
+        if title =~ /^(\w+-\d+) (.*)$/
+          [ $1, $2 ]
+        else
+          [ nil, title ]
+        end
+      end
+
+      # extracts the summary section from the pr and returns it (or returns nil
+      # if no summary section is detected)
+      def extract_summary(pr)
+        summary = []
+        accumulating = false
+        level = nil
+
+        pr['body'].lines.each do |line|
+          # a header of any level titled "summary" will begin the summary
+          if !accumulating && line =~ /^(\#+)\s+summary\s+$/i
+            accumulating = true
+            level = $1.length
+
+          # a header of any level less than or equal to the summary header's
+          # level will end the summary
+          elsif accumulating && line =~ /^\#{1,#{level}}\s+/
+            break
+
+          # otherwise, the line is part of the summary
+          elsif accumulating
+            summary << line
+          end
+        end
+
+        summary.any? ? summary.join.strip : nil
+      end
+
+      # Returns a symbol (:bcbreak, :feature, or :bug) that identifies the
+      # type of this PR that would most strongly influence what type of release
+      # it requires.
+      def pr_type(pr)
+        if pr['labels'].any? { |l| l['name'] == BCBREAK }
+          :bcbreak
+        elsif pr['labels'].any? { |l| l['name'] == FEATURE }
+          :feature
+        elsif pr['labels'].any? { |l| l['name'] == BUG }
+          :bug
+        else
+          nil
+        end
+      end
+
+      # `true` if the `patch` label is applied to the PR. This is used to
+      # indicate that a "feature" PR should be treated as a patch, for
+      # determining the release type only.
+      def pr_patch_flag?(pr)
+        pr['labels'].any? { |l| l['name'] == PATCH }
+      end
+
+      def pr_type_code(type)
+        case type
+        when :bcbreak then 'x'
+        when :feature then 'f'
+        when :bug     then 'b'
+        else '?'
+        end
+      end
+
+      def series
+        major, minor, = product.version_parts
+
+        case release_type
+        when 'minor' then 
+          "#{major}.x"
+        when 'patch' then
+          "#{major}.#{minor}.x"
+        end
+      end
+
+      # Return a string containing the markdown-formatted intro block for
+      # the release notes of this candidate.
+      def release_notes_intro
+        release_description = case release_type
+                              when 'major' then 'major release'
+                              when 'minor' then "minor release in the #{series} series"
+                              when 'patch' then "patch release in the #{series} series"
+                              end
+
+        <<~INTRO
+          The MongoDB Ruby team is pleased to announce version #{product.version} of the `#{product.package}` gem - #{product.description}. This is a new #{release_description} of #{product.name}.
+
+          Install this release using [RubyGems](https://rubygems.org/) via the command line as follows: 
+
+          ~~~
+          gem install -v #{product.version} #{product.package}
+          ~~~
+
+          Or simply add it to your `Gemfile`:
+
+          ~~~
+          gem '#{product.package}', '#{product.version}'
+          ~~~
+
+          Have any feedback? Click on through to MongoDB's JIRA and [open a new ticket](#{product.jira_project_url}) to let us know what's on your mind 🧠.
+
+        INTRO
+      end
+    end
+  end
+end

data/spec/shared/lib/mrss/release/product_data.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Mrss
+  module Release
+    class ProductData
+      FILE_PATH = 'product.yml'
+
+      def self.init!
+        if File.exist?(FILE_PATH)
+          raise "#{FILE_PATH} already exists; refusing to overwrite it"
+        end
+
+        initial_data = {
+          'name' => 'Product Name',
+          'description' => 'a very short description of the product',
+          'package' => 'product_package',
+          'jira' => 'https://url.to.jira/project',
+          'version' => { 'number' => '1.0.0',
+                         'file' => 'path/to/version.rb' }
+        }
+
+        File.write(FILE_PATH, initial_data.to_yaml)
+      end
+
+      def initialize
+        @hash = YAML.load_file(FILE_PATH)
+      end
+
+      def save_product_file!
+        File.write(FILE_PATH, @hash.to_yaml)
+      end
+
+      def rewrite_version_file!
+        version_module = File.read(version_file)
+        new_module = version_module.
+          sub(/^(\s*)(VERSION\s*=\s*).*$/) { "#{$1}#{$2}#{quoted_version}" }
+        File.write(version_file, new_module)
+      end
+
+      def version
+        @hash['version']['number']
+      end
+
+      def quoted_version
+        if version.include?("'")
+          version.inspect
+        else
+          "'#{version}'"
+        end
+      end
+
+      def version=(number)
+        @hash['version']['number'] = number
+      end
+
+      # returns an array of [ major, minor, patch, suffix ].
+      #
+      # each element will be returned as a String.
+      def version_parts
+        version.split(/\./, 4)
+      end
+
+      # bump the version according to the given release type:
+      #
+      #  'major' -> increment major component, zero the others
+      #  'minor' -> increment minor component, zero the patch
+      #  'patch' -> increment the patch component
+      def bump_version(release)
+        major, minor, patch, suffix = version_parts
+
+        case release
+        when 'major' then
+          major = major.to_i + 1
+          minor = patch = 0
+        when 'minor'
+          minor = minor.to_i + 1
+          patch = 0
+        when 'patch'
+          patch = patch.to_i + 1
+        else
+          raise ArgumentError, "invalid release type: #{release.inspect}"
+        end
+
+        self.version = [ major, minor, patch ].join('.')
+      end
+
+      # Invokes `#bump_version`, and then saves the new version to the
+      # product.yml file and to the version.rb file.
+      def bump_version!(release)
+        bump_version(release)
+        save_product_file!
+        rewrite_version_file!
+      end
+
+      def version_file
+        @hash['version']['file']
+      end
+
+      def name
+        @hash['name']
+      end
+
+      # The description is intended to be used in places where it can be
+      # appended to the end of a sentence, e.g.
+      #
+      #   "We just released #{product.name} - #{product.description}!"
+      #
+      # Markdown formatting is allowed (even expected).
+      def description
+        @hash['description']
+      end
+
+      def package
+        @hash['package']
+      end
+
+      def jira_project_url
+        @hash['jira']
+      end
+
+      def tag_name
+        "v#{version}"
+      end
+
+      def tag_exists?(tag = tag_name)
+        `git tag -l #{tag}`.strip == tag
+      end
+
+      def branch_exists?(branch)
+        `git branch -l #{branch}`.strip == branch
+      end
+
+      def base_branch
+        @base_branch ||= begin
+                           major, minor, = version_parts
+                           branch = "#{major}.#{minor}-stable"
+                           branch_exists?(branch) ? branch : 'master'
+                         end
+      end
+    end
+  end
+end

data/spec/shared/lib/mrss/server_version_registry.rb

@@ -19,11 +19,26 @@ module Mrss
     end
 
     def initialize(desired_version, arch)
-      @desired_version, @arch = desired_version, arch
+      @desired_version, @arch = desired_version, arch.sub(/-arm$/, '')
     end
 
     attr_reader :desired_version, :arch
 
+    def target_arch
+      # can't use RbConfig::CONFIG["arch"] because JRuby doesn't
+      # return anything meaningful there.
+      #
+      # also, need to use `uname -a` instead of (e.g.) `uname -p`
+      # because debian (at least) does not return anything meaningful
+      # for `uname -p`.
+      uname = `uname -a`.strip
+      @target_arch ||= case uname
+        when /aarch/ then "aarch64"
+        when /x86/   then "x86_64"
+        else raise "unsupported architecture #{uname.inspect}"
+        end
+    end
+
     def download_url
       @download_url ||= begin
         version, version_ok = detect_version(current_catalog)
@@ -40,35 +55,13 @@ module Mrss
         end
         dl = version['downloads'].detect do |dl|
           dl['archive']['url'].index("enterprise-#{arch}") &&
-          dl['arch'] == 'x86_64'
+          dl['arch'] == target_arch
         end
         unless dl
           raise MissingDownloadUrl, "No download for #{arch} for #{version['version']}"
         end
         url = dl['archive']['url']
       end
-    rescue MissingDownloadUrl
-      if %w(2.6 3.0).include?(desired_version) && arch == 'ubuntu1604'
-        # 2.6 and 3.0 are only available for ubuntu1204 and ubuntu1404.
-        # Those ubuntus have ancient Pythons that don't work due to not
-        # implementing recent TLS protocols.
-        # Because of this we test on ubuntu1604 which has a newer Python.
-        # But we still need to retrieve ubuntu1404-targeting builds.
-        url = self.class.new('3.2', arch).download_url
-        unless url.include?('3.2.')
-          raise 'URL not in expected format'
-        end
-        url = case desired_version
-        when '2.6'
-          url.sub(/\b3\.2\.\d+/, '2.6.12')
-        when '3.0'
-          url.sub(/\b3\.2\.\d+/, '3.0.15')
-        else
-          raise NotImplementedError
-        end.sub('ubuntu1604', 'ubuntu1404')
-      else
-        raise
-      end
     end
 
     private

data/spec/shared/lib/mrss/spec_organizer.rb

@@ -25,19 +25,19 @@ module Mrss
     end
 
     def initialize(root: nil, classifiers:, priority_order:,
-      spec_root: nil, rspec_json_path: nil, rspec_all_json_path: nil,
-      randomize: false
+      spec_root: nil, rspec_json_path: nil, rspec_all_json_path: nil, rspec_xml_path: nil, randomize: false
     )
       @spec_root = spec_root || File.join(root, 'spec')
       @classifiers = classifiers
       @priority_order = priority_order
       @rspec_json_path = rspec_json_path || File.join(root, 'tmp/rspec.json')
       @rspec_all_json_path = rspec_all_json_path || File.join(root, 'tmp/rspec-all.json')
+      @rspec_xml_path = rspec_xml_path || File.join(root, 'tmp/rspec.xml')
       @randomize = !!randomize
     end
 
     attr_reader :spec_root, :classifiers, :priority_order
-    attr_reader :rspec_json_path, :rspec_all_json_path
+    attr_reader :rspec_json_path, :rspec_all_json_path, :rspec_xml_path
 
     def randomize?
       @randomize
@@ -47,6 +47,25 @@ module Mrss
       @seed ||= (rand * 100_000).to_i
     end
 
+    # Remove all XML files from tmp directory before running tests
+    def cleanup_xml_files
+      xml_pattern = File.join(File.dirname(rspec_xml_path), '*.xml')
+      Dir.glob(xml_pattern).each do |xml_file|
+        FileUtils.rm_f(xml_file)
+      end
+    end
+
+    # Move the XML file to a timestamped version for evergreen upload
+    def archive_xml_file(category)
+      return unless File.exist?(rspec_xml_path)
+
+      timestamp = Time.now.strftime('%Y%m%d_%H%M%S_%3N')
+      archived_path = rspec_xml_path.sub(/\.xml$/, "-#{category}-#{timestamp}.xml")
+
+      FileUtils.mv(rspec_xml_path, archived_path)
+      puts "Archived XML results to #{archived_path}"
+    end
+
     def buckets
       @buckets ||= {}.tap do |buckets|
         Find.find(spec_root) do |path|
@@ -96,6 +115,8 @@ module Mrss
 
     def run_buckets(*buckets)
       FileUtils.rm_f(rspec_all_json_path)
+      # Clean up all XML files before starting test runs
+      cleanup_xml_files
 
       buckets.each do |bucket|
         if bucket && !self.buckets[bucket]
@@ -131,7 +152,12 @@ module Mrss
     def run_files(category, paths)
       puts "Running #{category.to_s.gsub('_', ' ')} tests"
       FileUtils.rm_f(rspec_json_path)
+      FileUtils.rm_f(rspec_xml_path)  # Clean up XML file before running this bucket
+
       cmd = %w(rspec) + paths
+      # Add junit formatter for XML output
+      cmd += ['--format', 'Rfc::Riff', '--format', 'RspecJunitFormatter', '--out', rspec_xml_path]
+
       if randomize?
         cmd += %W(--order rand:#{seed})
       end
@@ -147,6 +173,9 @@ module Mrss
             FileUtils.cp(rspec_json_path, rspec_all_json_path)
           end
         end
+
+        # Archive XML file after running this bucket
+        archive_xml_file(category)
       end
 
       true

data/spec/shared/lib/mrss/utils.rb

@@ -3,13 +3,35 @@
 
 module Mrss
   module Utils
+    extend self
 
-    module_function def print_backtrace(dest=STDERR)
-      begin
-        hello world
-      rescue => e
-        dest.puts e.backtrace.join("\n")
-      end
+    def print_backtrace(dest=STDERR)
+      raise
+    rescue => e
+      dest.puts e.backtrace.join("\n")
+    end
+
+    # Parses the given version string, accounting for suffix information that
+    # Gem::Version cannot successfully parse.
+    #
+    # @param [ String ] version the version to parse
+    #
+    # @return [ Gem::Version ] the parsed version
+    #
+    # @raise [ ArgumentError ] if the string cannot be parsed.
+    def parse_version(version)
+      Gem::Version.new(version)
+    rescue ArgumentError
+      match = version.match(/\A(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)?(-[A-Za-z\+\d]+)?\z/)
+      raise ArgumentError.new("Malformed version number string #{version}") if match.nil?
+
+      Gem::Version.new(
+        [
+          match[:major],
+          match[:minor],
+          match[:patch]
+        ].join('.')
+      )
     end
   end
 end

data/spec/shared/lib/tasks/candidate.rake

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../mrss/release/candidate'
+
+namespace :candidate do
+  desc 'Initialize a new product.yml file'
+  task :init do
+    Mrss::Release::ProductData.init!
+    puts "product.yml file created"
+  end
+
+  desc 'Print the release notes for the next candidate release'
+  task :preview do
+    Mrss::Release::Candidate.instance do |candidate|
+      # load the pending changes before bumping the version, since it
+      # depends on the value of the current version.
+      candidate.pending_changes
+      candidate.bump_version
+      puts candidate.release_notes
+    end
+  end
+
+  desc 'List the pull requests to be included in the next release'
+  task :prs do
+    Mrss::Release::Candidate.instance.decorated_prs.each do |pr|
+      print "\##{pr['number']}[#{pr['type-code']}] "
+      print "#{pr['jira']} " if pr['jira']
+      puts pr['short-title']
+    end
+  end
+
+  desc 'Create a new branch and pull request for the candidate'
+  task create: :check_branch_status do
+    Mrss::Release::Candidate.instance do |candidate|
+      origin = `git config get remote.origin.url`
+      match = origin.match(/:(.*?)\//) or raise "origin url is not in expected format: #{origin.inspect}"
+      user = match[1]
+
+      puts 'gathering candidate info and bumping version...'
+      candidate.bump_version!
+
+      puts 'writing release notes to /tmp/pr-body.md...'
+      File.write('/tmp/pr-body.md', candidate.release_notes)
+
+      sh 'git', 'checkout', '-b', candidate.branch_name
+      sh 'git', 'commit', '-am', "Bump version to #{candidate.product.version}"
+      sh 'git', 'push', 'origin', candidate.branch_name
+
+      sh 'gh', 'pr', 'create',
+           '--head', "#{user}:#{candidate.branch_name}",
+           '--base', candidate.product.base_branch,
+           '--title', "Release candidate for #{candidate.product.version}",
+           '--label', 'release-candidate',
+           '--body-file', '/tmp/pr-body.md'
+    end
+  end
+
+  # Ensures the current branch is up-to-date with no uncommitted changes
+  task :check_branch_status do
+    sh 'git pull >/dev/null', verbose: false
+    changes = `git status --short --untracked-files=no`.strip
+    abort "There are uncommitted changes. Commit (or revert) the changes and try again." if changes.length > 0
+  end
+end