webvalve 1.3.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94d2cb2a5a975fb3dc734272460423bb27c6909d49a80b807161da8b95a97da1
-  data.tar.gz: cc3df67e4361e88d496937ec37dc65619b96371c8ae52c6f4c217e434a7edddc
+  metadata.gz: e03b34e13263947acd26c73387bc7f1dcf6f8ae5749463fc83187fd43d75dc98
+  data.tar.gz: 85994585f1c19f5f63ea966fdc7c919e5e870e650c980fbea10accb30fb568ef
 SHA512:
-  metadata.gz: 6c9202365a83879f8df5123ef802d075c4f6dc8ae475a76258035bbecbc9031e8c9fef27c0e4eb343448530d174ef47f8507f1711683918fa4ad2b749f27bfda
-  data.tar.gz: c0a15038e8064bcd8bcfae0b2f13560a05e86b4d3df96a29a0a77366f985a86640ccc3a65b0d7350bd991fbe46f7c578c565b180ecfccbc572c2a352c90ff262
+  metadata.gz: '02801b418f46db96e7d6ef9cfad07c39a29054cd2a7357cfbb39029838a2cbf733f1e1a183590e731a6ef734fa6061de2a265eca761cffdccd3882d1b24ecb7e'
+  data.tar.gz: a100512db4c9e940a7853d168b7d0269db9e688048df3be24b1ccd31e4b881f64a3a14ec4da83bb1c9192ccd4867fe660ff30ebe2a8659f5b3ed59cc5d325d2d

data/CHANGELOG.md

@@ -9,6 +9,10 @@ and this project aims to adhere to [Semantic Versioning](http://semver.org/spec/
 ### Added
 ### Removed
 
+## [2.0.0] - 2023-07-20
+### Added
+- Dynamic URL support via wildcards, Regexps, and Addressable::Templates
+
 ## [1.3.1] - 2023-07-20
 ### Changed
 - Replace usage of deprecated `File.exists?` in generator

data/README.md

@@ -218,6 +218,43 @@ WebValve.register FakeBank, url: ENV.fetch("SOME_CUSTOM_API_URL")
 WebValve.register FakeBank, url: "https://some-service.com"
 ```
 
+## Dynamic URLs
+
+If the service you are interacting with contains dynamic elements, e.g.
+an instance-specific subdomain, you can specify a wildcard in your url
+with the `*` character to match a series of zero or more characters
+within the same URL segment. For example:
+
+```bash
+export BANK_API_URL=https://*.mybank.com/
+```
+
+or
+
+```ruby
+WebValve.register FakeBank, url: "https://*.mybank.com"
+```
+
+Note: unlike filesystem globbing, `?` isn't respected to mean "exactly
+one character" because it's a URL delimiter character. Only `*` works
+for WebValve URL wildcards.
+
+Alternatively you can use `Addressable::Template`s or `Regexp`s to
+specify dynamic URLs if they for some reason aren't a good fit for the
+wildcard syntax. Note that there is no `ENV` var support for these
+formats because there is no detection logic to determine a URL string is
+actually meant to represent a URL template or regexp. For example:
+
+```ruby
+WebValve.register FakeBank, url: Addressable::Template.new("http://mybank.com{/path*}{?query}")
+```
+
+or
+
+```ruby
+WebValve.register FakeBank, url: %r{\Ahttp://mybank.com(/.*)?\z}
+```
+
 ## What's in a `FakeService`?
 
 The definition of `FakeService` is really simple. It's just a

data/lib/webvalve/manager.rb

@@ -1,6 +1,7 @@
 require 'webmock'
 require 'singleton'
 require 'set'
+require 'webvalve/service_url_converter'
 
 module WebValve
   ALWAYS_ENABLED_ENVS = %w(development test).freeze
@@ -148,7 +149,7 @@ module WebValve
     end
 
     def url_to_regexp(url)
-      %r(\A#{Regexp.escape url})
+      ServiceUrlConverter.new(url: url).regexp
     end
 
     def ensure_non_duplicate_stub(config)

data/lib/webvalve/service_url_converter.rb

@@ -0,0 +1,24 @@
+module WebValve
+  class ServiceUrlConverter
+    TOKEN_BOUNDARY_CHARS = Regexp.escape('.:/?#@&=').freeze
+    WILDCARD_SUBSTITUTION = ('[^' + TOKEN_BOUNDARY_CHARS + ']*').freeze
+    URL_PREFIX_BOUNDARY = ('[' + TOKEN_BOUNDARY_CHARS + ']').freeze
+    URL_SUFFIX_PATTERN = ('((' + URL_PREFIX_BOUNDARY + '|(?<=' + URL_PREFIX_BOUNDARY + ')).*)?\z').freeze
+
+    attr_reader :url
+
+    def initialize(url:)
+      @url = url
+    end
+
+    def regexp
+      if url.is_a?(String)
+        regexp_string = Regexp.escape(url)
+        substituted_regexp_string = regexp_string.gsub('\*', WILDCARD_SUBSTITUTION)
+        %r(\A#{substituted_regexp_string}#{URL_SUFFIX_PATTERN})
+      else
+        url
+      end
+    end
+  end
+end

data/lib/webvalve/version.rb

@@ -1,3 +1,3 @@
 module WebValve
-  VERSION = "1.3.1"
+  VERSION = "2.0.0"
 end

data/spec/webvalve/manager_spec.rb

@@ -38,6 +38,9 @@ RSpec.describe WebValve::Manager do
   end
 
   describe '#setup' do
+    let(:wildcard_substitution) { WebValve::ServiceUrlConverter::WILDCARD_SUBSTITUTION }
+    let(:url_suffix_pattern) { WebValve::ServiceUrlConverter::URL_SUFFIX_PATTERN }
+
     context 'when WebValve is disabled' do
       around do |ex|
         with_rails_env 'production' do
@@ -94,10 +97,17 @@ RSpec.describe WebValve::Manager do
 
       it 'allowlists configured urls in webmock' do
         allow(WebMock).to receive(:disable_net_connect!)
-        results = [%r{\Ahttp://foo\.dev}, %r{\Ahttp://bar\.dev}]
+        results = [
+          %r{\Ahttp://foo\.dev#{url_suffix_pattern}},
+          %r{\Ahttp://bar\.dev#{url_suffix_pattern}},
+          %r{\Ahttp://bar\.#{wildcard_substitution}\.dev#{url_suffix_pattern}},
+          %r{\Ahttp://bar\.dev/\?foo=bar#{url_suffix_pattern}}
+        ]
 
         subject.allow_url 'http://foo.dev'
         subject.allow_url 'http://bar.dev'
+        subject.allow_url 'http://bar.*.dev'
+        subject.allow_url 'http://bar.dev/?foo=bar'
 
         subject.setup
 
@@ -115,7 +125,7 @@ RSpec.describe WebValve::Manager do
           subject.setup
         end
 
-        expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\.dev})
+        expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\.dev#{url_suffix_pattern}})
         expect(web_mock_stubble).to have_received(:to_rack)
       end
 
@@ -153,7 +163,7 @@ RSpec.describe WebValve::Manager do
           subject.register other_disabled_service.name
 
           expect { subject.setup }.to_not raise_error
-          expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\.dev}).twice
+          expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\.dev#{url_suffix_pattern}}).twice
         end
       end
     end
@@ -208,8 +218,8 @@ RSpec.describe WebValve::Manager do
             subject.setup
           end
 
-          expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\.dev})
-          expect(WebMock).not_to have_received(:stub_request).with(:any, %r{\Ahttp://other\.dev})
+          expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\.dev#{url_suffix_pattern}})
+          expect(WebMock).not_to have_received(:stub_request).with(:any, %r{\Ahttp://other\.dev#{url_suffix_pattern}})
           expect(web_mock_stubble).to have_received(:to_rack).once
         end
 
@@ -261,9 +271,9 @@ RSpec.describe WebValve::Manager do
           subject.setup
         end
 
-        expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\.dev})
-        expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\-else\.dev})
-        expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://other\.dev})
+        expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\.dev#{url_suffix_pattern}})
+        expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://something\-else\.dev#{url_suffix_pattern}})
+        expect(WebMock).to have_received(:stub_request).with(:any, %r{\Ahttp://other\.dev#{url_suffix_pattern}})
         expect(web_mock_stubble).to have_received(:to_rack).exactly(3).times
       end
     end

data/spec/webvalve/service_url_converter_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+RSpec.describe WebValve::ServiceUrlConverter do
+  let(:url) { "http://bar.com" }
+
+  subject { described_class.new(url: url) }
+
+  describe '#regexp' do
+    it "returns a regexp" do
+      expect(subject.regexp).to be_a(Regexp)
+    end
+
+    context "with a regexp" do
+      let(:url) { %r{\Ahttp://foo\.com} }
+
+      it "returns the same object" do
+        expect(subject.regexp).to be_a(Regexp)
+        expect(subject.regexp).to equal(url)
+      end
+    end
+
+    context "with an empty url" do
+      let(:url) { "" }
+
+      it "matches empty string" do
+        expect("").to match(subject.regexp)
+      end
+
+      it "matches a string starting with a URL delimiter because the rest is just interpreted as suffix" do
+        expect(":do:do:dodo:do:do").to match(subject.regexp)
+      end
+
+      it "doesn't match a string that doesn't start with a delimiter" do
+        expect("jamietart:do:do:dodo:do:do").not_to match(subject.regexp)
+      end
+    end
+
+    context "with a boundary char on the end" do
+      let(:url) { "http://bar.com/" }
+
+      it "matches arbitrary suffixes" do
+        expect("http://bar.com/baz/bump/beep").to match(subject.regexp)
+      end
+    end
+
+    context "with multiple asterisks" do
+      let(:url) { "http://bar.com/**/bump" }
+
+      it "matches like a single asterisk" do
+        expect("http://bar.com/foo/bump").to match(subject.regexp)
+      end
+
+      it "doesn't match like a filesystem glob" do
+        expect("http://bar.com/foo/bar/bump").not_to match(subject.regexp)
+      end
+    end
+
+    context "with a trailing *" do
+      let(:url) { "http://bar.com/*" }
+
+      it "matches when empty" do
+        expect("http://bar.com/").to match(subject.regexp)
+      end
+
+      it "matches when existing" do
+        expect("http://bar.com/foobaloo").to match(subject.regexp)
+      end
+
+      it "matches with additional tokens" do
+        expect("http://bar.com/foobaloo/wink").to match(subject.regexp)
+      end
+
+      it "doesn't match when missing the trailing slash tho" do
+        expect("http://bar.com").not_to match(subject.regexp)
+      end
+    end
+
+    context "with a totally wildcarded protocol" do
+      let(:url) { "*://bar.com" }
+
+      it "matches http" do
+        expect("http://bar.com/").to match(subject.regexp)
+      end
+
+      it "matches anything else" do
+        expect("gopher://bar.com/").to match(subject.regexp)
+      end
+
+      it "matches empty" do
+        expect("://bar.com").to match(subject.regexp)
+      end
+    end
+
+    context "with a wildcarded partial protocol" do
+      let(:url) { "http*://bar.com" }
+
+      it "matches empty" do
+        expect("http://bar.com/").to match(subject.regexp)
+      end
+
+      it "matches full" do
+        expect("https://bar.com/").to match(subject.regexp)
+      end
+    end
+
+    context "with a TLD that is a substring of another TLD" do
+      let(:url) { "http://bar.co" }
+
+      it "doesn't match a different TLD when extending" do
+        expect("http://bar.com").not_to match(subject.regexp)
+      end
+    end
+
+    context "with a wildcard subdomain" do
+      let(:url) { "http://*.bar.com" }
+
+      it "matches" do
+        expect("http://foo.bar.com").to match(subject.regexp)
+      end
+
+      it "doesn't match when too many subdomains" do
+        expect("http://beep.foo.bar.com").not_to match(subject.regexp)
+      end
+    end
+
+    context "with a partial postfix wildcard subdomain" do
+      let(:url) { "http://foo*.bar.com" }
+
+      it "matches when present" do
+        expect("http://foobaz.bar.com").to match(subject.regexp)
+      end
+
+      it "matches when empty" do
+        expect("http://foo.bar.com").to match(subject.regexp)
+      end
+
+      it "doesn't match when out of order" do
+        expect("http://bazfoo.bar.com").not_to match(subject.regexp)
+      end
+    end
+
+    context "with a partial prefix wildcard subdomain" do
+      let(:url) { "http://*baz.bar.com" }
+
+      it "matches when present" do
+        expect("http://foobaz.bar.com").to match(subject.regexp)
+      end
+
+      it "matches when empty" do
+        expect("http://baz.bar.com").to match(subject.regexp)
+      end
+    end
+
+    context "with a wildcarded basic auth url" do
+      let(:url) { "http://*:*@bar.com" }
+
+      it "matches when present" do
+        expect("http://bilbo:baggins@bar.com").to match(subject.regexp)
+      end
+
+      it "doesn't match when malformed" do
+        expect("http://bilbobaggins@bar.com").not_to match(subject.regexp)
+      end
+
+      it "doesn't match when missing password part" do
+        expect("http://bilbo@bar.com").not_to match(subject.regexp)
+      end
+    end
+
+    context "with a wildcarded path" do
+      let(:url) { "http://bar.com/*/whatever" }
+
+      it "matches with arbitrarily spicy but legal, non-URL-significant characters" do
+        expect("http://bar.com/a0-_~[]!$'(),;%+/whatever").to match(subject.regexp)
+      end
+
+      it "doesn't match when you throw a URL-significant char in there" do
+        expect("http://bar.com/life=love/whatever").not_to match(subject.regexp)
+      end
+    end
+
+    context "with a wildcarded query param" do
+      let(:url) { "http://bar.com/whatever?foo=*&bar=bump" }
+
+      it "matches when present" do
+        expect("http://bar.com/whatever?foo=baz&bar=bump").to match(subject.regexp)
+      end
+
+      it "doesn't match when you throw a URL-significant char in there" do
+        expect("http://bar.com/whatever?foo=baz#&bar=bump").not_to match(subject.regexp)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webvalve
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Sam Moore
@@ -173,6 +173,7 @@ files:
 - lib/webvalve/monkey_patches.rb
 - lib/webvalve/railtie.rb
 - lib/webvalve/rspec.rb
+- lib/webvalve/service_url_converter.rb
 - lib/webvalve/version.rb
 - spec/dummy/config/application.rb
 - spec/examples.txt
@@ -182,13 +183,28 @@ files:
 - spec/webvalve/fake_service_config_spec.rb
 - spec/webvalve/fake_service_spec.rb
 - spec/webvalve/manager_spec.rb
+- spec/webvalve/service_url_converter_spec.rb
 - spec/webvalve_spec.rb
 homepage: https://github.com/Betterment/webvalve
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
+post_install_message: |
+  Thanks for installing WebValve!
+
+  Note for upgraders: If you're upgrading from a version less than 2.0, service
+  URL behavior has changed. Please verify that your app isn't relying on the
+  previous behavior:
+
+  1. `*` characters are now interpreted as wildcards, enabling dynamic URL
+     segments. In the unlikely event that your URLs use `*` literals, you'll need
+     to URL encode them (`%2A`) both in your URL spec and at runtime.
+
+  2. URL suffix matching is now strict. For example, `BAR_URL=http://bar.co` will
+     no longer match `https://bar.com`, but it will match `http://bar.co/foo`. If
+     you need to preserve the previous behavior, you can add a trailing `*` to
+     your URL spec, e.g. `BAR_URL=http://bar.co*`.
 rdoc_options: []
 require_paths:
 - lib
@@ -216,4 +232,5 @@ test_files:
 - spec/webvalve/fake_service_config_spec.rb
 - spec/webvalve/fake_service_spec.rb
 - spec/webvalve/manager_spec.rb
+- spec/webvalve/service_url_converter_spec.rb
 - spec/webvalve_spec.rb