Add ability to use release candidate API version

Falls back to latest API version for REST resources

Author: lizkenyon

lib/shopify_api/admin_versions.rb

@@ -3,8 +3,11 @@
 
 module ShopifyAPI
   module AdminVersions
+    extend T::Sig
+
     SUPPORTED_ADMIN_VERSIONS = T.let([
       "unstable",
+      "2025-04",
       "2025-01",
       "2024-10",
       "2024-07",
@@ -21,8 +24,31 @@ module AdminVersions
     ], T::Array[String])
 
     LATEST_SUPPORTED_ADMIN_VERSION = T.let("2025-01", String)
+    RELEASE_CANDIDATE_ADMIN_VERSION = T.let("2025-04", String)
+
+    class << self
+      extend T::Sig
+
+      sig { params(version: String).returns(String) }
+      def rest_resource_version(version)
+        if version == RELEASE_CANDIDATE_ADMIN_VERSION && !rest_resources_exist?(version)
+          LATEST_SUPPORTED_ADMIN_VERSION
+        else
+          version
+        end
+      end
+
+      private
+
+      sig { params(version: String).returns(T::Boolean) }
+      def rest_resources_exist?(version)
+        version_folder_name = version.gsub("-", "_")
+        Dir.exist?("#{__dir__}/rest/resources/#{version_folder_name}")
+      end
+    end
   end
 
   SUPPORTED_ADMIN_VERSIONS = ShopifyAPI::AdminVersions::SUPPORTED_ADMIN_VERSIONS
   LATEST_SUPPORTED_ADMIN_VERSION = ShopifyAPI::AdminVersions::LATEST_SUPPORTED_ADMIN_VERSION
+  RELEASE_CANDIDATE_ADMIN_VERSION = ShopifyAPI::AdminVersions::RELEASE_CANDIDATE_ADMIN_VERSION
 end

lib/shopify_api/context.rb

@@ -104,13 +104,15 @@ def load_rest_resources(api_version:)
         # No resources for the unstable version
         return if api_version == "unstable"
 
-        version_folder_name = api_version.gsub("-", "_")
+        # Use the rest_version method to handle fallback for release candidate versions
+        version_to_load = ShopifyAPI::AdminVersions.rest_resource_version(api_version)
+        version_folder_name = version_to_load.gsub("-", "_")
         path = "#{__dir__}/rest/resources/#{version_folder_name}"
 
         unless Dir.exist?(path)
-          unless @notified_missing_resources_folder.key?(api_version)
+          unless @notified_missing_resources_folder.key?(version_to_load)
             @logger.warn("Cannot autoload REST resources for API version '#{version_folder_name}', folder is missing")
-            @notified_missing_resources_folder[api_version] = true
+            @notified_missing_resources_folder[version_to_load] = true
           end
 
           return

test/admin_versions_test.rb

@@ -12,5 +12,42 @@ def test_supported_admin_versions
     def test_supported_latest_supported_admin_version
       assert_instance_of(String, ShopifyAPI::AdminVersions::LATEST_SUPPORTED_ADMIN_VERSION)
     end
+
+    def test_rest_version_returns_version_when_resources_exist
+      # Mock the private rest_resources_exist? method to return true
+      ShopifyAPI::AdminVersions.stub(:rest_resources_exist?, true) do
+        version = ShopifyAPI::AdminVersions::RELEASE_CANDIDATE_ADMIN_VERSION
+        assert_equal(version, ShopifyAPI::AdminVersions.rest_resource_version(version))
+      end
+    end
+
+    def test_rest_version_returns_latest_supported_when_resources_dont_exist
+      # Mock the private rest_resources_exist? method to return false
+      ShopifyAPI::AdminVersions.stub(:rest_resources_exist?, false) do
+        version = ShopifyAPI::AdminVersions::RELEASE_CANDIDATE_ADMIN_VERSION
+        assert_equal(ShopifyAPI::AdminVersions::LATEST_SUPPORTED_ADMIN_VERSION,
+          ShopifyAPI::AdminVersions.rest_resource_version(version))
+      end
+    end
+
+    def test_rest_version_returns_version_for_non_release_candidate
+      # For any version that's not the release candidate, it should return the version as is
+      version = ShopifyAPI::AdminVersions::LATEST_SUPPORTED_ADMIN_VERSION
+      assert_equal(version, ShopifyAPI::AdminVersions.rest_resource_version(version))
+    end
+
+    def test_rest_resources_exist_checks_directory
+      # We can test the private method by using send
+      version = "2025-01"
+      expected_path = "#{File.expand_path("../..", __FILE__)}/lib/shopify_api/rest/resources/2025_01"
+
+      # Mock Dir.exist? to verify it's called with the right path
+      Dir.stub(:exist?, ->(path) {
+                          assert_equal(expected_path, path)
+                          true
+                        }) do
+        assert(ShopifyAPI::AdminVersions.send(:rest_resources_exist?, version))
+      end
+    end
   end
 end

test/context_test.rb

@@ -201,6 +201,63 @@ def test_rest_disabled_can_be_set_in_setup
       assert(ShopifyAPI::Context.rest_disabled)
     end
 
+    def test_load_rest_resources_uses_rest_resource_version
+      # Test that the rest_resource_version method is used to handle fallback for release candidate versions
+      release_candidate = ShopifyAPI::AdminVersions::RELEASE_CANDIDATE_ADMIN_VERSION
+      latest_supported = ShopifyAPI::AdminVersions::LATEST_SUPPORTED_ADMIN_VERSION
+
+      ShopifyAPI::AdminVersions.expects(:rest_resource_version).with(release_candidate).returns(latest_supported)
+      version_folder_name = latest_supported.gsub("-", "_")
+      Dir.expects(:exist?).with(regexp_matches(%r{.*/lib/shopify_api/rest/resources/#{version_folder_name}$})).returns(true)
+      original_method = Zeitwerk::Loader.method(:new)
+
+      begin
+        # Create a real Zeitwerk::Loader instance that we can stub
+        loader = Zeitwerk::Loader.new
+        Zeitwerk::Loader.stubs(:new).returns(loader)
+
+        # Now stub the methods on the real loader
+        loader.expects(:enable_reloading).once
+        loader.expects(:ignore).once
+        loader.expects(:setup).once
+        loader.expects(:push_dir).once
+        loader.expects(:reload).once
+
+        # Call load_rest_resources with the release candidate version
+        ShopifyAPI::Context.load_rest_resources(api_version: release_candidate)
+      ensure
+        # Restore the original method to avoid affecting other tests
+        Zeitwerk::Loader.singleton_class.send(:define_method, :new, original_method)
+      end
+    end
+
+    def test_load_rest_resources_when_resources_dont_exist
+      # Test behavior when REST resources directory doesn't exist
+      version = "2023-01"
+      version_folder_name = version.gsub("-", "_")
+
+      # Mock Dir.exist? to return false, indicating resources don't exist
+      Dir.expects(:exist?).with(regexp_matches(%r{.*/lib/shopify_api/rest/resources/#{version_folder_name}$})).returns(false)
+
+      # Reset the notified_missing_resources_folder hash to ensure warning is logged
+      ShopifyAPI::Context.instance_variable_set(:@notified_missing_resources_folder, {})
+
+      # Expect a warning to be logged
+      logger_mock = mock
+      logger_mock.expects(:warn).with(regexp_matches(/Cannot autoload REST resources for API version '#{version_folder_name}'/))
+      ShopifyAPI::Context.instance_variable_set(:@logger, logger_mock)
+
+      # Ensure Zeitwerk loader is not created or used
+      Zeitwerk::Loader.expects(:new).never
+
+      # Call load_rest_resources with the version
+      ShopifyAPI::Context.load_rest_resources(api_version: version)
+
+      # Verify the version was added to the notified list
+      notified = ShopifyAPI::Context.instance_variable_get(:@notified_missing_resources_folder)
+      assert(notified.key?(version), "Version should be added to notified_missing_resources_folder")
+    end
+
     def teardown
       ShopifyAPI::Context.deactivate_session
     end