mongoid 7.5.4 → 7.6.1

data/spec/mongoid/serializable_spec.rb

@@ -528,13 +528,11 @@ describe Mongoid::Serializable do
             end
 
             it "includes the first relation" do
-              expect(relation_hash[0]).to include
-                { "_id" => "kudamm", "street" => "Kudamm" }
+              expect(relation_hash[0]).to include({ "_id" => "kudamm", "street" => "Kudamm" })
             end
 
             it "includes the second relation" do
-              expect(relation_hash[1]).to include
-                { "_id" => "tauentzienstr", "street" => "Tauentzienstr" }
+              expect(relation_hash[1]).to include( "_id" => "tauentzienstr", "street" => "Tauentzienstr" )
             end
           end
 
@@ -545,13 +543,11 @@ describe Mongoid::Serializable do
             end
 
             it "includes the first relation" do
-              expect(relation_hash[0]).to include
-                { "_id" => "kudamm", "street" => "Kudamm" }
+              expect(relation_hash[0]).to include({ "_id" => "kudamm", "street" => "Kudamm" })
             end
 
             it "includes the second relation" do
-              expect(relation_hash[1]).to include
-                { "_id" => "tauentzienstr", "street" => "Tauentzienstr" }
+              expect(relation_hash[1]).to include({ "_id" => "tauentzienstr", "street" => "Tauentzienstr" })
             end
           end
 
@@ -670,8 +666,7 @@ describe Mongoid::Serializable do
             end
 
             it "includes the specified relation" do
-              expect(relation_hash).to include
-                { "_id" => "leo-marvin", "first_name" => "Leo", "last_name" => "Marvin" }
+              expect(relation_hash).to include({ "_id" => "Leo-Marvin", "first_name" => "Leo", "last_name" => "Marvin" })
             end
           end
 
@@ -682,8 +677,7 @@ describe Mongoid::Serializable do
             end
 
             it "includes the specified relation" do
-              expect(relation_hash).to include
-                { "_id" => "leo-marvin", "first_name" => "Leo", "last_name" => "Marvin" }
+              expect(relation_hash).to include({ "_id" => "Leo-Marvin", "first_name" => "Leo", "last_name" => "Marvin" })
             end
           end
 
@@ -694,8 +688,7 @@ describe Mongoid::Serializable do
             end
 
             it "includes the specified relation sans exceptions" do
-              expect(relation_hash).to include
-                { "first_name" => "Leo", "last_name" => "Marvin" }
+              expect(relation_hash).to include({ "first_name" => "Leo", "last_name" => "Marvin" })
             end
           end
         end

data/spec/shared/CANDIDATE.md

@@ -0,0 +1,28 @@
+# Candidate Tasks
+
+When using the `candidate` rake tasks, you must make sure:
+
+1. You are using at least `git` version 2.49.0.
+2. You have the `gh` CLI tool installed.
+3. You are logged into `gh` with an account that has collaborator access to the repository.
+4. You have run `gh repo set-default` from the root of your local checkout to set the default repository to the canonical MongoDB repo.
+5. The `origin` remote for your local checkout is set to your own fork.
+6. The `upstream` remote for your local checkout is set to the canonical
+   MongoDB repo.
+
+Once configured, you can use the following commands:
+
+1. `rake candidate:prs` - This will list all pull requests that will be included in the next release. Any with `[?]` are unlabelled (or are not labelled with a recognized label). Otherwise, `[b]` means `bug`, `[f]` means `feature`, and `[x]` means `bcbreak`.
+2. `rake candidate:preview` - This will generate and display the release notes for the next release, based on the associated pull requests.
+3. `rake candidate:create` - This will create a new PR against the default repository, using the generated release notes as the description. The new PR will be given the `release-candidate` label.
+
+Then, after the release candidate PR is approved and merged, the release process will automatically bundle, sign, and release the new version.
+
+Once you've merged the PR, you can switch to the "Actions" tab for the repository on GitHub and look for the "Release" workflow (might be named differently), which should have triggered automatically. You can monitor the progress of the release there. If there are any problems, the workflow is generally safe to re-run after you've addressed them.
+
+Things to do after the release succeeds:
+
+1. Copy the release notes from the PR and create a new release announcement on the forums (https://www.mongodb.com/community/forums/c/announcements/driver-releases/110).
+2. If the release was not automatically announced in #ruby, copy a link to the GitHub release or MongoDB forum post there.
+3. Close the release in Jira.
+

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

@@ -195,12 +195,15 @@ module Mrss
       'debian81' => 'debian:jessie',
       'debian92' => 'debian:stretch',
       'debian10' => 'debian:buster',
+      'debian11' => 'debian:bullseye',
       'ubuntu1404' => 'ubuntu:trusty',
       'ubuntu1604' => 'ubuntu:xenial',
       'ubuntu1804' => 'ubuntu:bionic',
       'ubuntu2004' => 'ubuntu:focal',
+      'ubuntu2204' => 'ubuntu:jammy',
       'rhel62' => 'centos:6',
       'rhel70' => 'centos:7',
+      'rhel80' => 'rockylinux:8',
     }.freeze
 
     def base_image
@@ -231,6 +234,10 @@ module Mrss
       distro =~ /debian|ubuntu/
     end
 
+    def ubuntu?
+      distro=~ /ubuntu/
+    end
+
     def preload?
       !!@options[:preload]
     end
@@ -275,7 +282,7 @@ module Mrss
 
     def num_exposed_ports
       case @env['TOPOLOGY'] || 'standalone'
-      when 'standalone'
+      when 'standalone', 'replica-set-single-node'
         1
       when 'replica-set'
         3

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

@@ -98,8 +98,8 @@ module Mrss
     def min_libmongocrypt_version(version)
       require_libmongocrypt
       before(:all) do
-        actual_version = Gem::Version.new(Mongo::Crypt::Binding.mongocrypt_version(nil))
-        min_version = Gem::Version.new(version)
+        actual_version = Utils.parse_version(Mongo::Crypt::Binding.mongocrypt_version(nil))
+        min_version = Utils.parse_version(version)
         unless actual_version >= min_version
           skip "libmongocrypt version #{min_version} required, but version #{actual_version} is available"
         end

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