dependabot-helm 0.323.0 → 0.324.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1bdd7ad27ed6ca980f7a26abd96df542c194546a335f72c20cb5dc7dc7f7130
-  data.tar.gz: 06d2472204b07e77dac65d3991092b24c6d61bd6f36e7e3e71ca5a53624aa8cc
+  metadata.gz: 109e220f0d5461102ca48999b9c0c8e8829fa81cd4fbb3e98f013ee36bd0014d
+  data.tar.gz: 16e970e8fd14f1563898e9ade684a155820287ffe37e3e069ee95c768205f26b
 SHA512:
-  metadata.gz: ea99e90aff1e8fefafb5279d9b5276bec8fe8f72873378d013dc22f87e6b64e3672f27af29a27a0afbbe27161b630f6b2f3526f7fc3b24065320b25881c49cf0
-  data.tar.gz: 8ffadf8d3dc7c2d33f7047cc9afd43b50dbe5f33507fd33364223ca393f2675546d37ba2f0c5a5a111e539c74600639f7625ea03dfc6f5f9632f2b101ebbfc93
+  metadata.gz: 8900634a48b88074240e35b088f6d9613edbd1a1e928725ea7d936a23f355d329a09374c35ecbb0fa5f406f70d6786aef120c3b446421c69cfeaca4d333cac75
+  data.tar.gz: 1e41b94ab1cc9272fbe025601dddc66fbc35e575bfe6dc6775cacab1bac737c834d1a39d1e9462d8267308339a82153faecf7cae4880f8ad76d0975213ae6ffd

data/lib/dependabot/helm/helpers.rb

@@ -52,36 +52,6 @@ module Dependabot
         )
       end
 
-      sig { params(username: String, password: String, repository_url: String).returns(String) }
-      def self.registry_login(username, password, repository_url)
-        Dependabot.logger.info("Logging into Helm registry \"#{repository_url}\"")
-
-        Dependabot::SharedHelpers.run_shell_command(
-          "helm registry login --username #{username} --password #{password} #{repository_url}",
-          fingerprint: "helm registry login --username <username> --password <password> <repository_url>"
-        )
-      rescue StandardError => e
-        Dependabot.logger.error(
-          "Failed to authenticate for #{repository_url}: #{e.message}"
-        )
-        raise
-      end
-
-      sig { params(username: String, password: String, repository_url: String).returns(String) }
-      def self.oci_registry_login(username, password, repository_url)
-        Dependabot.logger.info("Logging into OCI registry \"#{repository_url}\"")
-
-        Dependabot::SharedHelpers.run_shell_command(
-          "oras login --username #{username} --password #{password} #{repository_url}",
-          fingerprint: "oras login --username <username> --password <password> <repository_url>"
-        )
-      rescue StandardError => e
-        Dependabot.logger.error(
-          "Failed to authenticate for #{repository_url}: #{e.message}"
-        )
-        raise
-      end
-
       sig { params(name: String).returns(String) }
       def self.fetch_oci_tags(name)
         Dependabot.logger.info("Searching OCI tags for: #{name}")
@@ -91,6 +61,14 @@ module Dependabot
           fingerprint: "oras repo tags <name>"
         ).strip
       end
+
+      sig { params(repo_url: String, tag: String).returns(String) }
+      def self.fetch_tags_with_release_date_using_oci(repo_url, tag)
+        Dependabot::SharedHelpers.run_shell_command(
+          "oras manifest fetch #{repo_url}:#{tag}",
+          fingerprint: "oras manifest fetch <repo_url>:<tag>"
+        ).strip
+      end
     end
   end
 end

data/lib/dependabot/helm/package/package_details_fetcher.rb

@@ -0,0 +1,109 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "cgi"
+require "excon"
+require "sorbet-runtime"
+require "dependabot/helm"
+require "dependabot/helm/helpers"
+
+module Dependabot
+  module Helm
+    module Package
+      class PackageDetailsFetcher
+        extend T::Sig
+        # https://api.github.com/repos/prometheus-community/helm-charts/releases
+        RELEASES_URL_GIT = "https://api.github.com/repos/"
+        HELM_CHART_RELEASE = "/helm-charts/releases"
+        HELM_CHART_INDEX_URL = "https://repo.broadcom.com/bitnami-files/index.yaml"
+
+        sig do
+          params(
+            dependency: Dependency,
+            credentials: T::Array[Dependabot::Credential]
+          ).void
+        end
+        def initialize(dependency:, credentials:)
+          @dependency = dependency
+          @credentials = credentials
+        end
+
+        sig { returns(T::Array[Dependabot::Credential]) }
+        attr_reader :credentials
+
+        sig { returns(Dependabot::Dependency) }
+        attr_reader :dependency
+
+        sig { params(repo_name: String).returns(T::Array[GitTagWithDetail]) }
+        def fetch_tag_and_release_date_from_chart(repo_name)
+          return [] if repo_name.empty?
+
+          url = RELEASES_URL_GIT + repo_name + HELM_CHART_RELEASE
+          Dependabot.logger.info("Fetching graph release details from URL: #{url}")
+
+          begin
+            response = Excon.get(url, headers: { "Accept" => "application/vnd.github.v3+json" })
+          rescue Excon::Error => e
+            Dependabot.logger.error("Failed to fetch releases from #{url}: #{e.message} ")
+            return []
+          end
+
+          Dependabot.logger.error("Failed call details: #{response.body}") unless response.status == 200
+          return [] if response.status != 200
+
+          parse_github_response(response)
+        end
+
+        sig { params(response: Excon::Response).returns(T::Array[GitTagWithDetail]) }
+        def parse_github_response(response)
+          releases = JSON.parse(response.body)
+          result_lines = releases.map do |release|
+            GitTagWithDetail.new(
+              tag: release["tag_name"],
+              release_date: release["published_at"]
+            )
+          end
+          result_lines.sort_by(&:tag).reverse
+          rescue JSON::ParserError => e
+            Dependabot.logger.error("Failed to parse JSON response: #{e.message} response body #{response.body}")
+            []
+        end
+
+        sig { params(index_url: T.nilable(String), chart_name: String).returns(T::Array[GitTagWithDetail]) }
+        def fetch_tag_and_release_date_helm_chart_index(index_url, chart_name)
+          Dependabot.logger.info("Fetching fetch_tag_and_release_date_helm_chart_index:: #{index_url}")
+          index_url = HELM_CHART_INDEX_URL if index_url.nil? || index_url.empty?
+          result_lines = T.let([], T::Array[GitTagWithDetail])
+          begin
+            response = Excon.get(
+              index_url,
+              idempotent: true,
+              middlewares: Excon.defaults[:middlewares] + [Excon::Middleware::RedirectFollower]
+            )
+          rescue Excon::Error => e
+            Dependabot.logger.error("Error fetching Helm index from #{index_url}: #{e.message}")
+            return result_lines
+          end
+          Dependabot.logger.info("Received response from #{index_url} with status #{response.status}")
+          begin
+            parsed_result = YAML.safe_load(response.body)
+          rescue Psych::SyntaxError => e
+            Dependabot.logger.error("Error parsing Helm index: #{e.message}")
+            return result_lines
+          end
+          return result_lines unless parsed_result && parsed_result["entries"] && parsed_result["entries"][chart_name]
+
+          parsed_result["entries"][chart_name].map do |release|
+            result_lines << GitTagWithDetail.new(
+              tag: release["version"], # Extract the version field
+              release_date: release["created"] # Extract the created field
+            )
+          end
+          result_lines
+        end
+      end
+    end
+  end
+end

data/lib/dependabot/helm/update_checker/latest_version_resolver.rb

@@ -0,0 +1,188 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "dependabot/helm/package/package_details_fetcher"
+require "sorbet-runtime"
+require "dependabot/git_commit_checker"
+require "dependabot/helm/version"
+
+module Dependabot
+  module Helm
+    class LatestVersionResolver
+      extend T::Sig
+
+      DAY_IN_SECONDS = T.let(24 * 60 * 60, Integer)
+
+      sig do
+        params(
+          dependency: Dependabot::Dependency,
+          credentials: T::Array[Dependabot::Credential],
+          cooldown_options: T.nilable(Dependabot::Package::ReleaseCooldownOptions)
+        ).void
+      end
+      def initialize(dependency:, credentials:, cooldown_options:)
+        @dependency = dependency
+        @credentials = credentials
+        @cooldown_options = cooldown_options
+      end
+
+      sig { returns(Dependabot::Dependency) }
+      attr_reader :dependency
+
+      # To filter versions in cooldown period based on version tags from registry call
+      sig do
+        params(tags: T::Array[String], tags_with_release_date: T::Array[GitTagWithDetail])
+          .returns(T::Array[String])
+      end
+      def filter_versions_in_cooldown_period_using_oci(tags, tags_with_release_date)
+        select_tags_which_in_cooldown_using_oci(tags_with_release_date)&.each do |tag_name|
+          # Iterate through versions and filter out those matching the tag_name
+          tags.reject! do |version|
+            version == tag_name
+          end
+        end
+        tags
+      rescue StandardError => e
+        Dependabot.logger.error("Error filter_versions_in_cooldown_period_for_oci:: #{e.message}")
+        tags
+      end
+
+      sig do
+        params(
+          versions: T::Array[T::Hash[String, T.untyped]],
+          repo_name: T.nilable(String),
+          chart_name: T.nilable(String)
+        )
+          .returns(T::Array[T::Hash[String, T.untyped]])
+      end
+      def fetch_tag_and_release_date_helm_chart(versions, repo_name, chart_name)
+        Dependabot.logger.info("Filtering versions in cooldown period from chart: #{repo_name}")
+        # Using index URL to fetch tags in cooldown period"
+        tags = select_tags_which_in_cooldown_from_chart_index("", T.must(chart_name))
+        # If no tags in result then check from github api.
+        tags = select_tags_which_in_cooldown_from_chart(T.must(repo_name)) if tags.nil? || tags.empty?
+
+        return versions if tags.nil? || tags.empty?
+
+        versions.reject! do |release|
+          tags.any?(release["version"])
+        end
+        versions
+      rescue StandardError => e
+        Dependabot.logger.error("Error fetch_tag_and_release_date_helm_chart(versions): #{e.message}")
+        versions
+      end
+
+      sig { params(repo_name: String).returns(T.nilable(T::Array[String])) }
+      def select_tags_which_in_cooldown_from_chart(repo_name)
+        version_tags_in_cooldown_from_chart = T.let([], T::Array[String])
+
+        begin
+          package_details_fetcher.fetch_tag_and_release_date_from_chart(repo_name).each do |git_tag_with_detail|
+            if check_if_version_in_cooldown_period?(T.must(git_tag_with_detail.release_date))
+              version_tags_in_cooldown_from_chart << git_tag_with_detail.tag
+            end
+          end
+          version_tags_in_cooldown_from_chart
+        rescue StandardError => e
+          Dependabot.logger.error("Error checking if version is in cooldown: #{e.message}")
+          version_tags_in_cooldown_from_chart
+        end
+      end
+
+      sig { params(index_url: String, versions: T::Array[String], chart_name: String).returns(T::Array[String]) }
+      def fetch_tag_and_release_date_helm_chart_index(index_url, versions, chart_name)
+        Dependabot.logger.info("Filtering versions in cooldown period from chart: #{index_url}")
+        return versions if select_tags_which_in_cooldown_from_chart_index(index_url, chart_name).nil?
+
+        select_tags_which_in_cooldown_from_chart_index(index_url, chart_name)&.each do |tag_name|
+          # Iterate through versions and filter out those matching the tag_name
+          versions.reject! do |version|
+            version == tag_name
+          end
+        end
+        Dependabot.logger.info("Allowed version tags after filtering versions in cooldown:
+              #{versions.map(&:to_s).join(', ')}")
+        versions
+      rescue StandardError => e
+        Dependabot.logger.error("Error fetch_tag_and_release_date_helm_chart_index : #{e.message}")
+        versions
+      end
+
+      sig { params(index_url: String, chart_name: String).returns(T.nilable(T::Array[String])) }
+      def select_tags_which_in_cooldown_from_chart_index(index_url, chart_name)
+        fetch_tag_and_release_date_helm_chart_index = T.let([], T::Array[String])
+
+        begin
+          package_details_fetcher.fetch_tag_and_release_date_helm_chart_index(index_url, chart_name).each do |git_tag|
+            if check_if_version_in_cooldown_period?(T.must(git_tag.release_date))
+              fetch_tag_and_release_date_helm_chart_index << git_tag.tag
+            end
+          end
+          fetch_tag_and_release_date_helm_chart_index
+        rescue StandardError => e
+          Dependabot.logger.error("Error checking if version is in cooldown: #{e.message}")
+          fetch_tag_and_release_date_helm_chart_index
+        end
+      end
+
+      sig { params(release_date: String).returns(T::Boolean) }
+      def check_if_version_in_cooldown_period?(release_date)
+        return false unless release_date.length.positive?
+
+        cooldown = @cooldown_options
+        return false unless cooldown
+
+        return false if cooldown.nil?
+
+        # Calculate the number of seconds passed since the release
+        passed_seconds = Time.now.to_i - release_date_to_seconds(release_date)
+        # Check if the release is within the cooldown period
+        passed_seconds < cooldown.default_days * DAY_IN_SECONDS
+      end
+
+      sig { params(release_date: String).returns(Integer) }
+      def release_date_to_seconds(release_date)
+        Time.parse(release_date).to_i
+      rescue ArgumentError => e
+        Dependabot.logger.error("Invalid release date format: #{release_date} and error: #{e.message}")
+        0 # Default to 360 days in seconds if parsing fails, so that it will not be in cooldown
+      end
+
+      sig { params(tags_with_release_date: T::Array[GitTagWithDetail]).returns(T.nilable(T::Array[String])) }
+      def select_tags_which_in_cooldown_using_oci(tags_with_release_date)
+        fetch_tag_and_release_date_helm_using_oci = T.let([], T::Array[String])
+
+        begin
+          tags_with_release_date.each do |git_tag_with_detail|
+            if check_if_version_in_cooldown_period?(T.must(git_tag_with_detail.release_date))
+              fetch_tag_and_release_date_helm_using_oci << git_tag_with_detail.tag
+            end
+          end
+          fetch_tag_and_release_date_helm_using_oci
+        rescue StandardError => e
+          Dependabot.logger.error("Error checking if version is in cooldown: #{e.message}")
+          fetch_tag_and_release_date_helm_using_oci
+        end
+      end
+
+      sig { returns(Package::PackageDetailsFetcher) }
+      def package_details_fetcher
+        @package_details_fetcher ||= T.let(
+          Package::PackageDetailsFetcher.new(
+            dependency: dependency,
+            credentials: credentials
+          ), T.nilable(Package::PackageDetailsFetcher)
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def cooldown_enabled?
+        Dependabot::Experiments.enabled?(:enable_cooldown_for_helm)
+      end
+
+      sig { returns(T::Array[Dependabot::Credential]) }
+      attr_reader :credentials
+    end
+  end
+end

data/lib/dependabot/helm/update_checker.rb

@@ -19,6 +19,8 @@ module Dependabot
     class UpdateChecker < Dependabot::UpdateCheckers::Base
       extend T::Sig
 
+      require_relative "update_checker/latest_version_resolver"
+
       sig { override.returns(T.nilable(T.any(String, Gem::Version))) }
       def latest_version
         @latest_version ||= T.let(fetch_latest_version, T.nilable(T.any(String, Gem::Version)))
@@ -67,6 +69,10 @@ module Dependabot
         valid_releases = filter_valid_releases(releases)
         return nil if valid_releases.empty?
 
+        if cooldown_enabled?
+          valid_releases =  latest_version_resolver
+                            .fetch_tag_and_release_date_helm_chart(valid_releases, repo_name, chart_name)
+        end
         highest_release = valid_releases.max_by { |release| version_class.new(release["version"]) }
         Dependabot.logger.info(
           "Found latest version #{T.must(highest_release)['version']} for #{chart_name} using helm search"
@@ -87,6 +93,14 @@ module Dependabot
         Dependabot.logger.info("Found #{all_versions.length} versions for #{chart_name} in index.yaml")
 
         valid_versions = filter_valid_versions(all_versions)
+        if cooldown_enabled?
+          # Filter out versions that are in cooldown period
+          valid_versions = latest_version_resolver.fetch_tag_and_release_date_helm_chart_index(
+            index_url,
+            valid_versions,
+            chart_name
+          )
+        end
         Dependabot.logger.info("After filtering, found #{valid_versions.length} valid versions for #{chart_name}")
 
         return nil if valid_versions.empty?
@@ -153,7 +167,6 @@ module Dependabot
         Dependabot.logger.info("Fetching releases for Helm chart: #{chart_name}")
 
         if repo_name && repo_url
-          authenticate_registry_source(repo_url)
           begin
             Helpers.add_repo(repo_name, repo_url)
             Helpers.update_repo
@@ -178,39 +191,12 @@ module Dependabot
         end
       end
 
-      sig { params(repo_url: T.nilable(String)).returns(T.nilable(String)) }
-      def authenticate_registry_source(repo_url)
-        return unless repo_url
-
-        repo_creds = Shared::Utils::CredentialsFinder.new(@credentials, private_repository_type: "helm_registry")
-                                                     .credentials_for_registry(repo_url)
-        return unless repo_creds
-
-        Helpers.registry_login(T.must(repo_creds["username"]), T.must(repo_creds["password"]), repo_url)
-      rescue StandardError
-        raise PrivateSourceAuthenticationFailure, repo_url
-      end
-
-      sig { params(repo_url: T.nilable(String)).returns(T.nilable(String)) }
-      def authenticate_oci_registry_source(repo_url)
-        return unless repo_url
-
-        repo_creds = Shared::Utils::CredentialsFinder.new(@credentials, private_repository_type: "helm_registry")
-                                                     .credentials_for_registry(repo_url)
-        return unless repo_creds
-
-        Helpers.oci_registry_login(T.must(repo_creds["username"]), T.must(repo_creds["password"]), repo_url)
-      rescue StandardError
-        raise PrivateSourceAuthenticationFailure, repo_url
-      end
-
       sig { returns(T.nilable(Gem::Version)) }
       def fetch_latest_chart_version
         chart_name = dependency.name
         source = dependency.requirements.first&.dig(:source)
         repo_url = source&.dig(:registry)
         repo_name = extract_repo_name(repo_url)
-
         releases = fetch_releases_with_helm_cli(chart_name, repo_name, repo_url)
         return releases if releases
 
@@ -226,6 +212,16 @@ module Dependabot
         return nil unless tags && !tags.empty?
 
         valid_tags = filter_valid_versions(tags)
+        if cooldown_enabled?
+          # Filter out versions that are in cooldown period
+          repo_url = repo_url.gsub("oci://", "")
+          repo_url = repo_url + "/" + chart_name
+          tags_with_release_date = fetch_tags_with_release_date_using_oci(valid_tags, repo_url)
+          valid_tags = latest_version_resolver.filter_versions_in_cooldown_period_using_oci(
+            valid_tags,
+            tags_with_release_date
+          )
+        end
         return nil if valid_tags.empty?
 
         highest_tag = valid_tags.map { |v| version_class.new(v) }.max
@@ -237,7 +233,6 @@ module Dependabot
       def fetch_oci_tags(chart_name, repo_url)
         Dependabot.logger.info("Fetching OCI tags for #{repo_url}")
         oci_registry = repo_url.gsub("oci://", "")
-        authenticate_oci_registry_source(repo_url)
 
         release_tags = Helpers.fetch_oci_tags("#{oci_registry}/#{chart_name}").split("\n")
         release_tags.map { |tag| tag.tr("_", "+") }
@@ -295,14 +290,26 @@ module Dependabot
 
         Dependabot.logger.info("Delegating to Docker UpdateChecker for image: #{docker_dependency.name}")
 
-        docker_checker = Dependabot::UpdateCheckers.for_package_manager("docker").new(
-          dependency: docker_dependency,
-          dependency_files: dependency_files,
-          credentials: credentials,
-          ignored_versions: ignored_versions,
-          security_advisories: security_advisories,
-          raise_on_ignored: raise_on_ignored
-        )
+        docker_checker = if cooldown_enabled?
+                           Dependabot::UpdateCheckers.for_package_manager("docker").new(
+                             dependency: docker_dependency,
+                             dependency_files: dependency_files,
+                             credentials: credentials,
+                             ignored_versions: ignored_versions,
+                             security_advisories: security_advisories,
+                             raise_on_ignored: raise_on_ignored,
+                             update_cooldown: update_cooldown
+                           )
+                         else
+                           Dependabot::UpdateCheckers.for_package_manager("docker").new(
+                             dependency: docker_dependency,
+                             dependency_files: dependency_files,
+                             credentials: credentials,
+                             ignored_versions: ignored_versions,
+                             security_advisories: security_advisories,
+                             raise_on_ignored: raise_on_ignored
+                           )
+                         end
 
         latest_version = docker_checker.latest_version
 
@@ -313,6 +320,36 @@ module Dependabot
         version_class.new(latest_version)
       end
 
+      sig { params(tags: T::Array[String], repo_url: String).returns(T::Array[GitTagWithDetail]) }
+      def fetch_tags_with_release_date_using_oci(tags, repo_url)
+        git_tag_with_release_date = T.let([], T::Array[GitTagWithDetail])
+        return git_tag_with_release_date if tags.empty?
+
+        tags = tags.sort.reverse.take(150) # Limit to 150 tags for performance
+        tags.each do |tag|
+          # Since the oras registry uses "_" instead of "+", this is a workaround
+          # to ensure the tag is correctly formatted for the OCI registry.
+          # This is necessary because some tags may contain "+" which is not valid in OCI tags.
+
+          temp_tag = tag.tr("+", "_")
+          response = Helpers.fetch_tags_with_release_date_using_oci(repo_url, temp_tag)
+
+          begin
+            parsed_response = JSON.parse(response)
+          rescue JSON::ParserError => e
+            Dependabot.logger.error("Failed to parse JSON response for tag #{tag}: #{e.message}")
+            next
+          end
+          git_tag_with_release_date << GitTagWithDetail.new(
+            tag: tag,
+            release_date: parsed_response.dig("annotations", "org.opencontainers.image.created")
+          )
+        rescue StandardError => e
+          Dependabot.logger.error("Error in fetching details for tag #{tag}: #{e.message}")
+        end
+        git_tag_with_release_date
+      end
+
       sig { returns(Dependabot::Dependency) }
       def build_docker_dependency
         source = T.must(dependency.requirements.first)[:source]
@@ -344,8 +381,27 @@ module Dependabot
           package_manager: "helm"
         )
       end
+
+      sig { returns(T::Boolean) }
+      def cooldown_enabled?
+        # This is a simple check to see if user has put cooldown days.
+        # If not set, then we aassume user does not want cooldown.
+        # Since Helm does not support Semver versioning, So option left
+        # for the user is to set cooldown default days.
+        return false if update_cooldown.nil?
+
+        T.must(update_cooldown&.default_days).positive?
+      end
+
+      sig { returns(LatestVersionResolver) }
+      def latest_version_resolver
+        LatestVersionResolver.new(
+          dependency: dependency,
+          credentials: credentials,
+          cooldown_options: update_cooldown
+        )
+      end
     end
   end
 end
-
 Dependabot::UpdateCheckers.register("helm", Dependabot::Helm::UpdateChecker)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dependabot-helm
 version: !ruby/object:Gem::Version
-  version: 0.323.0
+  version: 0.324.1
 platform: ruby
 authors:
 - Dependabot
@@ -15,28 +15,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.323.0
+        version: 0.324.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.323.0
+        version: 0.324.1
 - !ruby/object:Gem::Dependency
   name: dependabot-docker
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.323.0
+        version: 0.324.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.323.0
+        version: 0.324.1
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -263,15 +263,17 @@ files:
 - lib/dependabot/helm/file_updater/image_updater.rb
 - lib/dependabot/helm/file_updater/lock_file_generator.rb
 - lib/dependabot/helm/helpers.rb
+- lib/dependabot/helm/package/package_details_fetcher.rb
 - lib/dependabot/helm/package_manager.rb
 - lib/dependabot/helm/update_checker.rb
+- lib/dependabot/helm/update_checker/latest_version_resolver.rb
 - lib/dependabot/helm/version.rb
 homepage: https://github.com/dependabot/dependabot-core
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/dependabot/dependabot-core/issues
-  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.323.0
+  changelog_uri: https://github.com/dependabot/dependabot-core/releases/tag/v0.324.1
 rdoc_options: []
 require_paths:
 - lib