From 64eead8d470c2be1d06958d69694c16329c93247 Mon Sep 17 00:00:00 2001
From: Alex Aitken <alex.aitken@shopify.com>
Date: Fri, 9 Aug 2019 16:42:34 -0400
Subject: [PATCH 1/3] Add version coercion strategies.

---
 lib/shopify_api.rb                            |  4 +
 lib/shopify_api/api_version.rb                | 26 ++++---
 lib/shopify_api/version_coercers.rb           |  6 ++
 lib/shopify_api/version_coercers/base.rb      | 35 +++++++++
 .../version_coercers/defined_only.rb          | 14 ++++
 .../version_coercers/generate_release.rb      | 34 ++++++++
 test/api_version_test.rb                      | 77 ++++++++++++++++++-
 test/version_coercers/base_test.rb            | 17 ++++
 test/version_coercers/defined_only_test.rb    | 55 +++++++++++++
 .../version_coercers/generate_release_test.rb | 67 ++++++++++++++++
 test/version_coercers/interface_test_suite.rb | 46 +++++++++++
 11 files changed, 366 insertions(+), 15 deletions(-)
 create mode 100644 lib/shopify_api/version_coercers.rb
 create mode 100644 lib/shopify_api/version_coercers/base.rb
 create mode 100644 lib/shopify_api/version_coercers/defined_only.rb
 create mode 100644 lib/shopify_api/version_coercers/generate_release.rb
 create mode 100644 test/version_coercers/base_test.rb
 create mode 100644 test/version_coercers/defined_only_test.rb
 create mode 100644 test/version_coercers/generate_release_test.rb
 create mode 100644 test/version_coercers/interface_test_suite.rb

diff --git a/lib/shopify_api.rb b/lib/shopify_api.rb
index 9d35de5a7..50170216a 100644
--- a/lib/shopify_api.rb
+++ b/lib/shopify_api.rb
@@ -6,6 +6,10 @@
 require 'active_resource/detailed_log_subscriber'
 require 'shopify_api/limits'
 require 'shopify_api/defined_versions'
+require 'shopify_api/version_coercers'
+require 'shopify_api/version_coercers/base'
+require 'shopify_api/version_coercers/defined_only'
+require 'shopify_api/version_coercers/generate_release'
 require 'shopify_api/api_version'
 require 'active_resource/json_errors'
 require 'shopify_api/collection'
diff --git a/lib/shopify_api/api_version.rb b/lib/shopify_api/api_version.rb
index 5e5b2a0d6..2aa33964d 100644
--- a/lib/shopify_api/api_version.rb
+++ b/lib/shopify_api/api_version.rb
@@ -1,34 +1,38 @@
 # frozen_string_literal: true
 module ShopifyAPI
   class ApiVersion
-    class UnknownVersion < StandardError; end
     class InvalidVersion < StandardError; end
 
     extend DefinedVersions
 
     include Comparable
 
-    def self.coerce_to_version(version_or_name)
-      return version_or_name if version_or_name.is_a?(ApiVersion)
+    def self.versions
+      @versions ||= VersionCoercers::GenerateRelease.new
+    end
 
-      @versions ||= {}
-      @versions.fetch(version_or_name.to_s) do
-        raise UnknownVersion, "#{version_or_name} is not in the defined version set: #{@versions.keys.join(', ')}"
+    def self.coercion_mode=(mode)
+      if :defined_only == mode
+        @versions = VersionCoercers::DefinedOnly.new
+      else
+        @versions = VersionCoercers::GenerateRelease.new
       end
     end
 
-    def self.define_version(version)
-      @versions ||= {}
+    def self.coerce_to_version(version_or_name)
+      versions.coerce_to_version(version_or_name)
+    end
 
-      @versions[version.name] = version
+    def self.define_version(version)
+      versions.define_version(version)
     end
 
     def self.clear_defined_versions
-      @versions = {}
+      versions.clear_defined_versions
     end
 
     def self.latest_stable_version
-      @versions.values.select(&:stable?).sort.last
+      versions.known_versions.select(&:stable?).sort.last
     end
 
     def to_s
diff --git a/lib/shopify_api/version_coercers.rb b/lib/shopify_api/version_coercers.rb
new file mode 100644
index 000000000..52ab8fac8
--- /dev/null
+++ b/lib/shopify_api/version_coercers.rb
@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module ShopifyAPI
+  module VersionCoercers
+    class UnknownVersion < StandardError; end
+  end
+end
diff --git a/lib/shopify_api/version_coercers/base.rb b/lib/shopify_api/version_coercers/base.rb
new file mode 100644
index 000000000..d30857481
--- /dev/null
+++ b/lib/shopify_api/version_coercers/base.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module ShopifyAPI
+  module VersionCoercers
+    class Base
+      def initialize
+        @versions = {}
+      end
+
+      def coerce_to_version(version_or_name)
+        return version_or_name if version_or_name.is_a?(ApiVersion)
+        coerce_from_name(version_or_name.to_s)
+      end
+
+      def define_version(version)
+        versions[version.name] = version
+      end
+
+      def clear_defined_versions
+        @versions = {}
+      end
+
+      def known_versions
+        versions.values
+      end
+
+      protected
+
+      attr_reader :versions
+
+      def coerce_from_name(name)
+        raise NotImplementedError
+      end
+    end
+  end
+end
diff --git a/lib/shopify_api/version_coercers/defined_only.rb b/lib/shopify_api/version_coercers/defined_only.rb
new file mode 100644
index 000000000..3c21283ab
--- /dev/null
+++ b/lib/shopify_api/version_coercers/defined_only.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module ShopifyAPI
+  module VersionCoercers
+    class DefinedOnly < Base
+      protected
+
+      def coerce_from_name(name)
+        versions.fetch(name) do
+          raise UnknownVersion, "#{name} is not in the defined version set: #{versions.keys.join(', ')}"
+        end
+      end
+    end
+  end
+end
diff --git a/lib/shopify_api/version_coercers/generate_release.rb b/lib/shopify_api/version_coercers/generate_release.rb
new file mode 100644
index 000000000..493e30c21
--- /dev/null
+++ b/lib/shopify_api/version_coercers/generate_release.rb
@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module ShopifyAPI
+  module VersionCoercers
+    class GenerateRelease < Base
+      protected
+
+      def coerce_from_name(name)
+        versions.fetch(name) do
+          record_new_version(name)
+        end
+      end
+
+      private
+
+      def record_new_version(version_name)
+        new_version = create_new_version(version_name)
+        define_version(new_version)
+        new_version
+      end
+
+      def create_new_version(version_name)
+        if unstable_version.name == version_name
+          unstable_version
+        else
+          ApiVersion::Release.new(version_name)
+        end
+      end
+
+      def unstable_version
+        @unstable_version ||= ShopifyAPI::ApiVersion::Unstable.new
+      end
+    end
+  end
+end
diff --git a/test/api_version_test.rb b/test/api_version_test.rb
index b9cf16d55..777fa98de 100644
--- a/test/api_version_test.rb
+++ b/test/api_version_test.rb
@@ -5,6 +5,7 @@ class ApiVersionTest < Test::Unit::TestCase
   def teardown
     super
     ShopifyAPI::ApiVersion.clear_defined_versions
+    ShopifyAPI::ApiVersion.coercion_mode = :define_on_unknown
     ShopifyAPI::ApiVersion.define_known_versions
   end
 
@@ -27,25 +28,36 @@ def teardown
     assert_same(version, ShopifyAPI::ApiVersion.coerce_to_version(version))
   end
 
-  test "coerce_to_version converts a known version into a version object" do
+  test "defined_only coerce_to_version converts a known version into a version object" do
+    with_defined_only_coercion
+    ShopifyAPI::ApiVersion.clear_defined_versions
+
+
     versions = [
       ShopifyAPI::ApiVersion::Unstable.new,
       ShopifyAPI::ApiVersion::Release.new('2019-01'),
     ]
 
+    versions.each do |version|
+      ShopifyAPI::ApiVersion.define_version(version)
+    end
+
     assert_equal(versions, [
       ShopifyAPI::ApiVersion.coerce_to_version('unstable'),
       ShopifyAPI::ApiVersion.coerce_to_version('2019-01'),
     ])
   end
 
-  test "coerce_to_version raises when coercing a string that doesn't match a known version" do
-    assert_raises ShopifyAPI::ApiVersion::UnknownVersion do
+  test "defined_only coerce_to_version raises when coercing a string that doesn't match a known version" do
+    with_defined_only_coercion
+    ShopifyAPI::ApiVersion.clear_defined_versions
+
+    assert_raises ShopifyAPI::VersionCoercers::UnknownVersion do
       ShopifyAPI::ApiVersion.coerce_to_version('made up version')
     end
   end
 
-  test "additional defined versions will also be coerced" do
+  test "defined_only additional defined versions will also be coerced" do
     versions = [
       TestApiVersion.new('my_name'),
       TestApiVersion.new('other_name'),
@@ -61,6 +73,55 @@ def teardown
     ])
   end
 
+  test "define_on_unknown coerce_to_version converts any valid version string into a version object" do
+    with_define_on_unknown_coercion
+    ShopifyAPI::ApiVersion.clear_defined_versions
+
+    versions = [
+      ShopifyAPI::ApiVersion::Release.new('2030-02'),
+      ShopifyAPI::ApiVersion::Release.new('2033-02'),
+    ]
+
+    assert_equal(versions, [
+      ShopifyAPI::ApiVersion.coerce_to_version('2030-02'),
+      ShopifyAPI::ApiVersion.coerce_to_version('2033-02'),
+    ])
+  end
+
+  test "define_on_unknown coerce_to_version finds any defined version" do
+    with_define_on_unknown_coercion
+    ShopifyAPI::ApiVersion.clear_defined_versions
+
+    defined_version = TestApiVersion.new('other_name')
+    ShopifyAPI::ApiVersion.define_version(defined_version)
+
+    coerced_version = ShopifyAPI::ApiVersion.coerce_to_version('other_name')
+
+    assert_equal(defined_version, coerced_version)
+  end
+
+  test "define_on_unknown coerce_to_version defines a new version when coercing a string that doesn't match a known version" do
+    with_define_on_unknown_coercion
+    ShopifyAPI::ApiVersion.clear_defined_versions
+
+    undefined_version = ShopifyAPI::ApiVersion::Release.new('2030-01')
+
+    coerced_version = ShopifyAPI::ApiVersion.coerce_to_version('2030-01')
+    second_coerced_version = ShopifyAPI::ApiVersion.coerce_to_version('2030-01')
+
+    assert_equal(undefined_version, coerced_version)
+    assert_same(second_coerced_version, coerced_version)
+  end
+
+  test "define_on_unknown coerce_to_version fails for unknown version that is not valid release version name" do
+    with_define_on_unknown_coercion
+    ShopifyAPI::ApiVersion.clear_defined_versions
+
+    assert_raises ShopifyAPI::ApiVersion::InvalidVersion do
+      ShopifyAPI::ApiVersion.coerce_to_version('this is not right')
+    end
+  end
+
   test 'allows a release version with the correct format format to be created' do
     assert ShopifyAPI::ApiVersion::Release.new('2019-03')
   end
@@ -136,6 +197,14 @@ def teardown
     )
   end
 
+  def with_defined_only_coercion
+    ShopifyAPI::ApiVersion.coercion_mode = :defined_only
+  end
+
+  def with_define_on_unknown_coercion
+    ShopifyAPI::ApiVersion.coercion_mode = :define_on_unknown
+  end
+
   class TestApiVersion < ShopifyAPI::ApiVersion
     def initialize(name)
       @version_name = name
diff --git a/test/version_coercers/base_test.rb b/test/version_coercers/base_test.rb
new file mode 100644
index 000000000..1f0870012
--- /dev/null
+++ b/test/version_coercers/base_test.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require 'test_helper'
+require_relative './interface_test_suite'
+
+class VersionCoercersBaseTest < Test::Unit::TestCase
+  include VersionCoercersInterfaceTestSuite
+
+  def setup
+    @coercer = ShopifyAPI::VersionCoercers::Base.new
+  end
+
+  test "coerce_to_version calls subclass method to coerce anything that isn't already a version" do
+    assert_raises NotImplementedError do
+      @coercer.coerce_to_version('unstable')
+    end
+  end
+end
diff --git a/test/version_coercers/defined_only_test.rb b/test/version_coercers/defined_only_test.rb
new file mode 100644
index 000000000..a3a939020
--- /dev/null
+++ b/test/version_coercers/defined_only_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require 'test_helper'
+require_relative './interface_test_suite'
+
+class VersionCoercersDefinedOnlyTest < Test::Unit::TestCase
+  include VersionCoercersInterfaceTestSuite
+
+  def setup
+    @coercer = ShopifyAPI::VersionCoercers::DefinedOnly.new
+  end
+
+  test "coerce_to_version converts a known version into a version object" do
+    versions = [
+      ShopifyAPI::ApiVersion::Unstable.new,
+      ShopifyAPI::ApiVersion::Release.new('2019-01'),
+    ]
+
+    versions.each do |version|
+      @coercer.define_version(version)
+    end
+
+    assert_equal(versions, [
+      @coercer.coerce_to_version('unstable'),
+      @coercer.coerce_to_version('2019-01'),
+    ])
+  end
+
+  test "coerce_to_version raises when coercing a string that doesn't match a known version" do
+    assert_raises ShopifyAPI::VersionCoercers::UnknownVersion do
+      @coercer.coerce_to_version('made up version')
+    end
+  end
+
+  test "any defined versions will also be coerced" do
+    versions = [
+      TestApiVersion.new('my_name'),
+      TestApiVersion.new('other_name'),
+    ]
+
+    versions.each do |version|
+      @coercer.define_version(version)
+    end
+
+    assert_equal(versions, [
+      @coercer.coerce_to_version('my_name'),
+      @coercer.coerce_to_version('other_name'),
+    ])
+  end
+
+  class TestApiVersion < ShopifyAPI::ApiVersion
+    def initialize(name)
+      @version_name = name
+    end
+  end
+end
diff --git a/test/version_coercers/generate_release_test.rb b/test/version_coercers/generate_release_test.rb
new file mode 100644
index 000000000..696173ae6
--- /dev/null
+++ b/test/version_coercers/generate_release_test.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require 'test_helper'
+require_relative './interface_test_suite'
+
+class VersionCoercersGenerateReleaseTest < Test::Unit::TestCase
+  include VersionCoercersInterfaceTestSuite
+
+  def setup
+    @coercer = ShopifyAPI::VersionCoercers::GenerateRelease.new
+  end
+
+  test "coerce_to_version converts a known version into a version object" do
+    versions = [TestApiVersion.new('maded up')]
+
+    versions.each do |version|
+      @coercer.define_version(version)
+    end
+
+    assert_equal(versions, [
+      @coercer.coerce_to_version('maded up'),
+    ])
+  end
+
+  test "coerce_to_version converts any valid version string into a release version" do
+    versions = [
+      ShopifyAPI::ApiVersion::Release.new('2030-02'),
+      ShopifyAPI::ApiVersion::Release.new('2033-02'),
+    ]
+
+    assert_equal(versions, [
+      @coercer.coerce_to_version('2030-02'),
+      @coercer.coerce_to_version('2033-02'),
+    ])
+  end
+
+  test "coerce_to_version defines a new version when coercing a string that doesn't match a known version" do
+    undefined_version = ShopifyAPI::ApiVersion::Release.new('2030-01')
+
+    coerced_version = @coercer.coerce_to_version('2030-01')
+    second_coerced_version = @coercer.coerce_to_version('2030-01')
+
+    assert_equal(undefined_version, coerced_version)
+    assert_same(second_coerced_version, coerced_version)
+    assert_equal([undefined_version], @coercer.known_versions)
+  end
+
+  test "coerce_to_version defines unstable when the name is unstable" do
+    undefined_version = ShopifyAPI::ApiVersion::Unstable.new
+
+    coerced_version = @coercer.coerce_to_version('unstable')
+
+    assert_equal(undefined_version, coerced_version)
+    assert_equal([undefined_version], @coercer.known_versions)
+  end
+
+  test "coerce_to_version fails for unknown version that is not valid release version name" do
+    assert_raises ShopifyAPI::ApiVersion::InvalidVersion do
+      @coercer.coerce_to_version('this is not right')
+    end
+  end
+
+  class TestApiVersion < ShopifyAPI::ApiVersion
+    def initialize(name)
+      @version_name = name
+    end
+  end
+end
diff --git a/test/version_coercers/interface_test_suite.rb b/test/version_coercers/interface_test_suite.rb
new file mode 100644
index 000000000..3236d2a22
--- /dev/null
+++ b/test/version_coercers/interface_test_suite.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module VersionCoercersInterfaceTestSuite
+
+  def self.test(string, &block)
+    define_method("test_#{string}", &block)
+  end
+
+  test "coerce_to_version returns any version object given without a lookup" do
+    version = ShopifyAPI::ApiVersion::Unstable.new
+    assert_same(version, @coercer.coerce_to_version(version))
+  end
+
+  test "alls defined versions are available form known_versions" do
+    versions = [
+      TestApiVersion.new('my_name'),
+      TestApiVersion.new('other_name'),
+    ]
+
+    versions.each do |version|
+      @coercer.define_version(version)
+    end
+
+    assert_equal(versions, @coercer.known_versions)
+  end
+
+  test "clear_defined_versions removes all known versions" do
+    versions = [
+      TestApiVersion.new('my_name'),
+      TestApiVersion.new('other_name'),
+    ]
+
+    versions.each do |version|
+      @coercer.define_version(version)
+    end
+
+    @coercer.clear_defined_versions
+
+    assert_predicate(@coercer.known_versions, :empty?)
+  end
+
+  class TestApiVersion < ShopifyAPI::ApiVersion
+    def initialize(name)
+      @version_name = name
+    end
+  end
+end

From b88415e5e5d76b1e9ff4019a55e58f48ce9a6dd6 Mon Sep 17 00:00:00 2001
From: Alex Aitken <alex.aitken@shopify.com>
Date: Mon, 12 Aug 2019 15:00:56 -0400
Subject: [PATCH 2/3] Deprecate version coercer methods on ApiVersion.

---
 lib/shopify_api.rb                   |   3 -
 lib/shopify_api/api_version.rb       |  33 ++++---
 lib/shopify_api/defined_versions.rb  |  11 ---
 test/api_version_test.rb             | 123 +++------------------------
 test/detailed_log_subscriber_test.rb |   2 -
 test/test_helper.rb                  |   5 +-
 6 files changed, 27 insertions(+), 150 deletions(-)
 delete mode 100644 lib/shopify_api/defined_versions.rb

diff --git a/lib/shopify_api.rb b/lib/shopify_api.rb
index 50170216a..eb924b754 100644
--- a/lib/shopify_api.rb
+++ b/lib/shopify_api.rb
@@ -5,7 +5,6 @@
 require 'base64'
 require 'active_resource/detailed_log_subscriber'
 require 'shopify_api/limits'
-require 'shopify_api/defined_versions'
 require 'shopify_api/version_coercers'
 require 'shopify_api/version_coercers/base'
 require 'shopify_api/version_coercers/defined_only'
@@ -32,5 +31,3 @@ module ShopifyAPI
 else
   require 'active_resource/connection_ext'
 end
-
-ShopifyAPI::ApiVersion.define_known_versions
diff --git a/lib/shopify_api/api_version.rb b/lib/shopify_api/api_version.rb
index 2aa33964d..1a6dd1d07 100644
--- a/lib/shopify_api/api_version.rb
+++ b/lib/shopify_api/api_version.rb
@@ -2,37 +2,34 @@
 module ShopifyAPI
   class ApiVersion
     class InvalidVersion < StandardError; end
-
-    extend DefinedVersions
-
     include Comparable
 
-    def self.versions
-      @versions ||= VersionCoercers::GenerateRelease.new
+    def self.__coercer
+      @coercer ||= VersionCoercers::GenerateRelease.new
     end
 
-    def self.coercion_mode=(mode)
-      if :defined_only == mode
-        @versions = VersionCoercers::DefinedOnly.new
-      else
-        @versions = VersionCoercers::GenerateRelease.new
-      end
+    def self.coercer=(version_coercer)
+      @coercer = version_coercer
     end
 
     def self.coerce_to_version(version_or_name)
-      versions.coerce_to_version(version_or_name)
+      __coercer.coerce_to_version(version_or_name)
     end
 
     def self.define_version(version)
-      versions.define_version(version)
+      warn(
+        '[DEPRECATED] ShopifyAPI::ApiVersion.define_version is deprecated ' \
+        'call define_version on the Coercer you assigned'
+      )
+      __coercer.define_version(version)
     end
 
     def self.clear_defined_versions
-      versions.clear_defined_versions
-    end
-
-    def self.latest_stable_version
-      versions.known_versions.select(&:stable?).sort.last
+      warn(
+        '[DEPRECATED] ShopifyAPI::ApiVersion.clear_defined_versions is deprecated ' \
+        'use ShopifyAPI::ApiVersion.versions.clear_defined_versions instead.'
+      )
+      __coercer.clear_defined_versions
     end
 
     def to_s
diff --git a/lib/shopify_api/defined_versions.rb b/lib/shopify_api/defined_versions.rb
deleted file mode 100644
index 55bd3d8a9..000000000
--- a/lib/shopify_api/defined_versions.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-module ShopifyAPI
-  module DefinedVersions
-    def define_known_versions
-      define_version(ShopifyAPI::ApiVersion::Unstable.new)
-      define_version(ShopifyAPI::ApiVersion::Release.new('2019-04'))
-      define_version(ShopifyAPI::ApiVersion::Release.new('2019-07'))
-      define_version(ShopifyAPI::ApiVersion::Release.new('2019-10'))
-    end
-  end
-end
diff --git a/test/api_version_test.rb b/test/api_version_test.rb
index 777fa98de..2a68faa7d 100644
--- a/test/api_version_test.rb
+++ b/test/api_version_test.rb
@@ -4,9 +4,7 @@
 class ApiVersionTest < Test::Unit::TestCase
   def teardown
     super
-    ShopifyAPI::ApiVersion.clear_defined_versions
-    ShopifyAPI::ApiVersion.coercion_mode = :define_on_unknown
-    ShopifyAPI::ApiVersion.define_known_versions
+    ShopifyAPI::ApiVersion.coercer = ShopifyAPI::VersionCoercers::GenerateRelease.new
   end
 
   test "unstable version creates url that start with /admin/api/unstable/" do
@@ -23,103 +21,18 @@ def teardown
     )
   end
 
-  test "coerce_to_version returns any version object given" do
-    version = ShopifyAPI::ApiVersion::Unstable.new
-    assert_same(version, ShopifyAPI::ApiVersion.coerce_to_version(version))
-  end
-
-  test "defined_only coerce_to_version converts a known version into a version object" do
-    with_defined_only_coercion
-    ShopifyAPI::ApiVersion.clear_defined_versions
-
-
-    versions = [
-      ShopifyAPI::ApiVersion::Unstable.new,
-      ShopifyAPI::ApiVersion::Release.new('2019-01'),
-    ]
-
-    versions.each do |version|
-      ShopifyAPI::ApiVersion.define_version(version)
-    end
-
-    assert_equal(versions, [
-      ShopifyAPI::ApiVersion.coerce_to_version('unstable'),
-      ShopifyAPI::ApiVersion.coerce_to_version('2019-01'),
-    ])
-  end
-
-  test "defined_only coerce_to_version raises when coercing a string that doesn't match a known version" do
-    with_defined_only_coercion
-    ShopifyAPI::ApiVersion.clear_defined_versions
+  test "coerce_to_version delgates to declared version coercer" do
+    fake_version = TestApiVersion.new('from fake coercer')
 
-    assert_raises ShopifyAPI::VersionCoercers::UnknownVersion do
-      ShopifyAPI::ApiVersion.coerce_to_version('made up version')
+    fake_coercer = Class.new do
+      def coerce_to_version(version_name)
+        TestApiVersion.new('from fake coercer')
+      end
     end
-  end
-
-  test "defined_only additional defined versions will also be coerced" do
-    versions = [
-      TestApiVersion.new('my_name'),
-      TestApiVersion.new('other_name'),
-    ]
-
-    versions.each do |version|
-      ShopifyAPI::ApiVersion.define_version(version)
-    end
-
-    assert_equal(versions, [
-      ShopifyAPI::ApiVersion.coerce_to_version('my_name'),
-      ShopifyAPI::ApiVersion.coerce_to_version('other_name'),
-    ])
-  end
-
-  test "define_on_unknown coerce_to_version converts any valid version string into a version object" do
-    with_define_on_unknown_coercion
-    ShopifyAPI::ApiVersion.clear_defined_versions
-
-    versions = [
-      ShopifyAPI::ApiVersion::Release.new('2030-02'),
-      ShopifyAPI::ApiVersion::Release.new('2033-02'),
-    ]
-
-    assert_equal(versions, [
-      ShopifyAPI::ApiVersion.coerce_to_version('2030-02'),
-      ShopifyAPI::ApiVersion.coerce_to_version('2033-02'),
-    ])
-  end
-
-  test "define_on_unknown coerce_to_version finds any defined version" do
-    with_define_on_unknown_coercion
-    ShopifyAPI::ApiVersion.clear_defined_versions
-
-    defined_version = TestApiVersion.new('other_name')
-    ShopifyAPI::ApiVersion.define_version(defined_version)
-
-    coerced_version = ShopifyAPI::ApiVersion.coerce_to_version('other_name')
-
-    assert_equal(defined_version, coerced_version)
-  end
-
-  test "define_on_unknown coerce_to_version defines a new version when coercing a string that doesn't match a known version" do
-    with_define_on_unknown_coercion
-    ShopifyAPI::ApiVersion.clear_defined_versions
-
-    undefined_version = ShopifyAPI::ApiVersion::Release.new('2030-01')
-
-    coerced_version = ShopifyAPI::ApiVersion.coerce_to_version('2030-01')
-    second_coerced_version = ShopifyAPI::ApiVersion.coerce_to_version('2030-01')
 
-    assert_equal(undefined_version, coerced_version)
-    assert_same(second_coerced_version, coerced_version)
-  end
-
-  test "define_on_unknown coerce_to_version fails for unknown version that is not valid release version name" do
-    with_define_on_unknown_coercion
-    ShopifyAPI::ApiVersion.clear_defined_versions
+    ShopifyAPI::ApiVersion.coercer = fake_coercer.new
 
-    assert_raises ShopifyAPI::ApiVersion::InvalidVersion do
-      ShopifyAPI::ApiVersion.coerce_to_version('this is not right')
-    end
+    assert_equal(fake_version, ShopifyAPI::ApiVersion.coerce_to_version('anything'))
   end
 
   test 'allows a release version with the correct format format to be created' do
@@ -183,26 +96,12 @@ def teardown
     ].sort)
   end
 
-  test 'latest_stable_version will return the version that is newest and stable' do
-    ShopifyAPI::ApiVersion.clear_defined_versions
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2017-11'))
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2019-11'))
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2039-01'))
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2039-02'))
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Unstable.new)
-
-    assert_equal(
-      ShopifyAPI::ApiVersion::Release.new('2039-02'),
-      ShopifyAPI::ApiVersion.latest_stable_version
-    )
-  end
-
   def with_defined_only_coercion
-    ShopifyAPI::ApiVersion.coercion_mode = :defined_only
+    ShopifyAPI::ApiVersion.coercer = ShopifyAPI::VersionCoercers::DefinedOnly.new
   end
 
   def with_define_on_unknown_coercion
-    ShopifyAPI::ApiVersion.coercion_mode = :define_on_unknown
+    ShopifyAPI::ApiVersion.coercer = ShopifyAPI::VersionCoercers::GenerateRelease.new
   end
 
   class TestApiVersion < ShopifyAPI::ApiVersion
diff --git a/test/detailed_log_subscriber_test.rb b/test/detailed_log_subscriber_test.rb
index 5c49babef..0628ea221 100644
--- a/test/detailed_log_subscriber_test.rb
+++ b/test/detailed_log_subscriber_test.rb
@@ -14,8 +14,6 @@ def setup
     @request_headers = "Headers: {\"Accept\"=>\"application/json\", " \
       "#{@ua_header}, \"X-Shopify-Access-Token\"=>\"access_token\"}"
 
-    ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2019-01'))
-
     ShopifyAPI::Base.clear_session
     session = ShopifyAPI::Session.new(
       domain: "https://this-is-my-test-shop.myshopify.com",
diff --git a/test/test_helper.rb b/test/test_helper.rb
index 6902c15be..cdbc7fa7c 100644
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -37,8 +37,6 @@ def setup
           end
         end
 
-        ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2019-01'))
-
         ShopifyAPI::Base.clear_session
         session = ShopifyAPI::Session.new(
           domain: "https://this-is-my-test-shop.myshopify.com",
@@ -55,8 +53,7 @@ def teardown
         ShopifyAPI::Base.password = nil
         ShopifyAPI::Base.user = nil
 
-        ShopifyAPI::ApiVersion.clear_defined_versions
-        ShopifyAPI::ApiVersion.define_known_versions
+        ShopifyAPI::ApiVersion.coercer = ShopifyAPI::VersionCoercers::GenerateRelease.new
       end
 
       # Custom Assertions

From c65684c023f91322c6b953689c8f3425fd5c539e Mon Sep 17 00:00:00 2001
From: Alex Aitken <alex.aitken@shopify.com>
Date: Wed, 14 Aug 2019 12:02:47 -0400
Subject: [PATCH 3/3] Update README with new api verison coercion scheme.

---
 README.md | 30 +++++++++++++++++++++++-------
 1 file changed, 23 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index 1304f6b84..b81f933ac 100644
--- a/README.md
+++ b/README.md
@@ -344,20 +344,36 @@ result = client.query(SHOP_NAME_QUERY)
 result.data.shop.name
 ```
 
-## Adding additional API versions
-We will release a gem update every time we release a new version of the API. Most of the time upgrading the gem will be all you need to do.
+## API versions
+Default setup for ShopifyApi will be support any string as an api version that is 'unstable' or matches the format 'YYYY-MM'
+
+
+### Stricter API version usage
+You have an option of only using api versions that you define.  This can be helpful to ensure you have stopped using older versions that you app no longer wants to rely on.
+
+To make use of this coercion option, add the following to initializing ShopifyApi
 
-If you want access to a newer version without upgrading you can define an api version.
-For example if you wanted to add an `ApiVersion` '2022-03', you would add the following to the initialization of your application:
 ```ruby
-ShopifyAPI::ApiVersion.define_version(ShopifyAPI::ApiVersion::Release.new('2022-03'))
+coercer = ShopifyAPI::VersionCoercers::DefinedOnly.new
+coercer.define_version(ShopifyAPI::ApiVersion::Release.new('2019-07')
+coercer.define_version(ShopifyAPI::ApiVersion::Unstable.new
+
+ShopifyAPI::ApiVersion.coercer = coercer
 ```
-Once you have done that you can now set this version in a Sesssion like this:
+
+Once you have done that, any use of an undefined version will raise a `ShopifyAPI::VersionCoercers::UnknownVersion` error.
 
 ```ruby
-ShopifyAPI::Session.new(domain: domain, token: token, api_version: '2022-03')
+ShopifyAPI::Session.new(domain: domain, token: token, api_version: '2019-04')
+# ShopifyAPI::VersionCoercers::UnknownVersion
 ```
 
+Defined version will work the same as the default setup.
+
+```ruby
+ShopifyAPI::Session.new(domain: domain, token: token, api_version: '2019-07')
+ShopifyAPI::Session.new(domain: domain, token: token, api_version: 'stable')
+```
 
 ## Threadsafety