bootic_client 0.0.31 → 0.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8906bbfeddb298199ecb675eea93c3780da4a370633bd73cb633bc10f893ae5
-  data.tar.gz: d0de74be08f4fffb7f68e02354dead206c67ee1db0662506668fe18ee0ebc4d3
+  metadata.gz: 355d7cbacb5e60ff2c051cc0f48452d01d4c099f0038dc5c0334a41811e8f5d3
+  data.tar.gz: fffcba9efcee1e1662e3337fd7ee25c1dbbe713f1153ed305f415a8a7c96e8a6
 SHA512:
-  metadata.gz: caa8411fdb9ab778b1e30c0c9c2e39ee0847a7d8a652658314d058d273b52c653ca85fc444aed5894d4406455965a32202c52365ac7a32ba085d54280360e4df
-  data.tar.gz: 1f4989cf0177a73128c9861cedc41a047a986c1ec70394311168b354e312da768d2f2530364c63748e0ed431e9f9b3642321c73e34266c3150500cdf5ae8c53a
+  metadata.gz: d8ffddf4c0a8825b5bad13e21a35c5b978d5629bf3025783c6fa42dab246dda845ab14e98694d949907698d7d81e01f779849e19c36421b471ecd6bc4d4d0c3c
+  data.tar.gz: fe5c3912de3febdb6ba374472e3a0996eb63f83504f8a5af266563f5b9cc46ed16b7a006fd22e66f83447669aef722893f1b24d4efd896f91638804d4a151be7

data/README.md

@@ -320,6 +320,40 @@ messaging_api_root = client.from_url("https://some.api.com")
 messaging_api.do_something(foo: "bar") # etc
 ```
 
+## Testing
+
+# What
+
+This library provides methods to simplify testing. For example, to stub a chain of links you can simply do:
+
+```rb
+BooticClient.stub_chain('root.shops.first').and_return_data({
+  'name' => 'Foo bar'
+})
+
+client = BooticClient.client(:authorized, access_token: 'abc')
+shop = client.root.shops.first
+expect(shop).to be_a BooticClient::Entity
+expect(shop.name).to eq 'Foo bar'
+```
+
+You can also stub links that requires arguments, like this:
+
+```rb
+BooticClient.stub_chain('root.shops', foo: 1).and_return_data({
+  'name' => 'Foo 1'
+})
+BooticClient.stub_chain('root.shops', foo: 1, bar: { hello: 123 }).and_return_data({
+  'name' => 'Foo 2'
+})
+
+client = BooticClient.client(:authorized, access_token: 'abc')
+expect(client.root.shops(foo: 1).name).to eq 'Foo 1'
+
+# arg order doesn't matter
+expect(client.root.shops(bar: { hello: 123 }, foo: 2).name).to eq 'Foo 2'
+```
+
 ## Contributing
 
 1. Fork it

data/lib/bootic_client/client.rb

@@ -108,15 +108,15 @@ module BooticClient
         yield req if block_given?
       end
 
-      raise_if_invalid! resp
+      raise_if_invalid! resp, "#{verb.upcase} #{href}"
       resp
     end
 
-    def raise_if_invalid!(resp)
-      raise ServerError, "Server Error" if resp.status > 499
-      raise NotFoundError, "Not Found" if resp.status == 404
-      raise UnauthorizedError, "Unauthorized request" if resp.status == 401
-      raise AccessForbiddenError, "Access Forbidden" if resp.status == 403
+    def raise_if_invalid!(resp, url = nil)
+      raise ServerError.new("Server Error", url) if resp.status > 499
+      raise NotFoundError.new("Not Found", url) if resp.status == 404
+      raise UnauthorizedError.new("Unauthorized Request", url) if resp.status == 401
+      raise AccessForbiddenError.new("Access Forbidden", url) if resp.status == 403
     end
 
     def sanitized(payload)

data/lib/bootic_client/entity.rb

@@ -15,9 +15,14 @@ module BooticClient
 
       Enumerator.new do |yielder|
         loop do
-          page.each{|item| yielder.yield item }
+          page.each { |item| yielder.yield(item) }
           raise StopIteration unless page.has_rel?(:next)
           page = page.next
+
+          if page.has?(:errors) # && page.errors.first.messages.first['cannot be higher'] # reached last page
+            yielder.yield(nil, page.errors) # yield a nil value so caller can stop gracefully
+            raise StopIteration
+          end
         end
       end
     end

data/lib/bootic_client/errors.rb

@@ -1,7 +1,14 @@
 # frozen_string_literal: true
 
 module BooticClient
-  class TransportError < StandardError; end
+  class TransportError < StandardError
+    attr_reader :url
+    def initialize(msg = nil, url = nil)
+      super(msg)
+      @url = url
+    end
+  end
+
   class ServerError < TransportError; end
   class NotFoundError < ServerError; end
   class AuthorizationError < ServerError; end

data/lib/bootic_client/stubbing.rb

@@ -0,0 +1,118 @@
+module BooticClient
+  module Stubbing
+    MissingStubError = Class.new(StandardError)
+
+    module Stubber
+      def from_hash(h)
+        self
+      end
+
+      def stub_chain(method_path, opts = {})
+        meths = method_path.split('.')
+        c = 0
+        opts = stringify_keys(opts)
+
+        meths.reduce(self) do |stub, method_name|
+          c += 1
+          a = c == meths.size ? opts : {}
+          stub.stub(method_name, a)
+        end
+      end
+
+      def stub(method_name, opts = {})
+        key = stub_key(method_name, opts)
+        if st = stubs[key]
+          st.stub(method_name, opts)
+          st
+        else
+          stubs[key] = Stub.new(method_name, opts)
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        opts = stringify_keys(args.first)
+        if stub = stubs[stub_key(method_name, opts)]
+          stub.returns? ? stub.returns : stub
+        else
+          raise MissingStubError, "No method stubbed for '#{method_name}' with options #{opts.inspect}"
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        stubs.keys.any?{|k|
+          k.to_s =~ /^#{method_name.to_s}/
+        }
+      end
+
+      private
+      def stub_key(method_name, opts)
+        [method_name.to_s, options_key(opts || {})].join('_')
+      end
+
+      def options_key(opts)
+        # sort keys
+        keys = opts.keys.sort
+        hash = keys.each_with_object({}) do |key, h|
+          value = if opts[key].is_a?(Hash)
+            options_key(opts[key])
+          else
+            opts[key].to_s
+          end
+
+          h[key] = value
+        end
+
+        hash.inspect
+      end
+
+      def stringify_keys(hash)
+        return hash unless hash.is_a?(Hash)
+
+        hash.each_with_object({}) do |(k, v), h|
+          h[k.to_s] = stringify_keys(v)
+        end
+      end
+    end
+
+    class StubRoot
+      include Stubber
+
+      def initialize
+        @stubs = {}
+      end
+
+      private
+      attr_reader :stubs
+    end
+
+    class Stub
+      include Stubber
+
+      def initialize(method_name = '', opts = {})
+        @method_name, @opts = method_name, opts
+        @return_data = nil
+        @stubs = {}
+      end
+
+      def and_return_data(data)
+        @return_data = data
+        self
+      end
+
+      def returns?
+        !!@return_data
+      end
+
+      def returns
+        if @return_data.is_a?(Array)
+          @return_data.map{|d| BooticClient::Entity.new(d, nil)}
+        else
+          BooticClient::Entity.new(@return_data || {}, nil)
+        end
+      end
+
+      private
+      attr_reader :stubs
+    end
+  end
+end

data/lib/bootic_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BooticClient
-  VERSION = "0.0.31".freeze
+  VERSION = "0.0.33".freeze
 end

data/lib/bootic_client.rb

@@ -12,6 +12,7 @@ module BooticClient
     end
 
     def client(strategy_name, client_opts = {}, &on_new_token)
+      return @stubber if @stubber
       opts = client_opts.dup
       opts[:logging] = configuration.logging
       opts[:logger] = configuration.logger if configuration.logging
@@ -21,6 +22,10 @@ module BooticClient
       strategies.fetch(strategy_name.to_sym).new configuration, opts, &on_new_token
     end
 
+    def auth_host
+      @auth_host || AUTH_HOST
+    end
+
     def configure(&block)
       yield configuration
     end
@@ -28,5 +33,18 @@ module BooticClient
     def configuration
       @configuration ||= Configuration.new
     end
+
+    def stub!
+      require "bootic_client/stubbing"
+      @stubber = Stubbing::StubRoot.new
+    end
+
+    def stub_chain(method_chain, opts = {})
+      @stubber.stub_chain(method_chain, opts)
+    end
+
+    def unstub!
+      @stubber = nil
+    end
   end
 end

data/spec/client_spec.rb

@@ -140,6 +140,12 @@ describe BooticClient::Client do
             expect{
               client.get(root_url)
             }.to raise_error(BooticClient::ServerError)
+
+            begin
+              client.get(root_url)
+            rescue BooticClient::ServerError => e
+              expect(e.url).to eq("GET #{root_url}")
+            end
           end
         end
 
@@ -153,6 +159,12 @@ describe BooticClient::Client do
             expect{
               client.get(root_url)
             }.to raise_error(BooticClient::NotFoundError)
+
+            begin
+              client.get(root_url)
+            rescue BooticClient::NotFoundError => e
+              expect(e.url).to eq("GET #{root_url}")
+            end
           end
         end
 
@@ -166,6 +178,12 @@ describe BooticClient::Client do
             expect{
               client.get(root_url)
             }.to raise_error(BooticClient::UnauthorizedError)
+
+            begin
+              client.get(root_url)
+            rescue BooticClient::UnauthorizedError => e
+              expect(e.url).to eq("GET #{root_url}")
+            end
           end
         end
 
@@ -179,6 +197,12 @@ describe BooticClient::Client do
             expect{
               client.get(root_url)
             }.to raise_error(BooticClient::AccessForbiddenError)
+
+            begin
+              client.get(root_url)
+            rescue BooticClient::AccessForbiddenError => e
+              expect(e.url).to eq("GET #{root_url}")
+            end
           end
         end
       end

data/spec/entity_spec.rb

@@ -232,6 +232,34 @@ describe BooticClient::Entity do
         titles = results.map(&:title)
         expect(titles).to match_array(['iPhone 4', 'iPhone 5', 'Item 3', 'Item 4'])
       end
+
+      it 'handles errors gracefully' do
+        error_data = {
+          "_embedded" => {
+            'errors' => [
+              { field: 'foo', messages: ['Ugly error'] }
+            ]
+          }
+        }
+
+        error_page = BooticClient::Entity.new(error_data, client)
+        expect(client).to receive(:request_and_wrap).with(:get, '/foo?page=2', {}).and_return(error_page)
+        expect(client).to_not receive(:request_and_wrap).with(:get, '/foo?page=3', {})
+
+        valid = []
+        errors = nil
+        entity.full_set.each do |item, errors|
+          if item
+            valid.push(item)
+          else
+            expect(valid.count).to eq(2)
+            expect(errors.first.to_hash).to eq({ field: 'foo', messages: ['Ugly error']})
+          end
+        end
+
+        titles = valid.map(&:title)
+        expect(titles).to match_array(['iPhone 4', 'iPhone 5'])
+      end
     end
   end
 

data/spec/stubbing_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe "stubbing" do
+  before do
+    BooticClient.stub!
+  end
+
+  after do
+    BooticClient.unstub!
+  end
+
+  it "stubs method chains and returns entities" do
+    BooticClient.stub_chain('root.shops.first').and_return_data({
+      'name' => 'Foo bar'
+    })
+
+    client = BooticClient.client(:authorized, access_token: 'abc')
+    shop = client.root.shops.first
+    expect(shop).to be_a BooticClient::Entity
+    expect(shop.name).to eq 'Foo bar'
+  end
+
+  it "stubs method chains and returns arrays of entities" do
+    BooticClient.stub_chain('root.shops').and_return_data([
+      {'name' => 'Foo bar'},
+      {'name' => 'Bar foo'}
+    ])
+
+    client = BooticClient.client(:authorized, access_token: 'abc')
+    shops = client.root.shops
+    expect(shops.first).to be_a BooticClient::Entity
+    expect(shops.last).to be_a BooticClient::Entity
+    expect(shops.first.name).to eq 'Foo bar'
+  end
+
+  it 'can be chained further' do
+    BooticClient.stub_chain('foo.bar')
+    client = BooticClient.client(:authorized, access_token: 'abc')
+
+    stub = client.foo.bar
+    stub.stub_chain('another.stubz').and_return_data({
+      'id' => 123
+    })
+
+    expect(stub.another.stubz.id).to eq 123
+  end
+
+  it 'stubs depending on arguments' do
+    BooticClient.stub_chain('root.shops', foo: 0).and_return_data({
+      'name' => 'Foo 0'
+    })
+    BooticClient.stub_chain('root.shops', foo: 1).and_return_data({
+      'name' => 'Foo 1'
+    })
+    BooticClient.stub_chain('root.shops', foo: 2, bar: {yup: 'yiss'}).and_return_data({
+      'name' => 'Foo 2'
+    })
+
+    client = BooticClient.client(:authorized, access_token: 'abc')
+
+    expect(client.root.shops(foo: 0).name).to eq 'Foo 0'
+    expect(client.root.shops(foo: 1).name).to eq 'Foo 1'
+    expect(client.root.shops(foo: 2, bar: {yup: 'yiss'}).name).to eq 'Foo 2'
+    # arg order shouldn't matter
+    expect(client.root.shops(bar: {yup: 'yiss'}, foo: 2).name).to eq 'Foo 2'
+
+    expect {
+      client.root.shops(foo: 2, bar: {yup: 'nope'})
+    }.to raise_error BooticClient::Stubbing::MissingStubError
+  end
+
+  it "stubs multiple chains with arguments" do
+    BooticClient.stub_chain('one.two', arg: 1).stub_chain('three.four').and_return_data('name' => 'example 1')
+    BooticClient.stub_chain('one.two', arg: 2).stub_chain('three.four').and_return_data('name' => 'example 2')
+
+    client = BooticClient.client(:authorized, access_token: 'abc')
+
+    expect(client.one.two(arg: 1).three.four.name).to eq 'example 1'
+    expect(client.one.two(arg: 2).three.four.name).to eq 'example 2'
+  end
+
+  it "treats symbol and string keys the same" do
+    BooticClient.stub_chain('one.two', arg: 1).and_return_data('name' => 'example 1')
+    client = BooticClient.client(:authorized, access_token: 'abc')
+
+    expect(client.one.two("arg" => 1).name).to eq 'example 1'
+  end
+
+  it "raises known exception if no stub found" do
+    client = BooticClient.client(:authorized, access_token: 'abc')
+
+    expect{
+      client.nope
+    }.to raise_error BooticClient::Stubbing::MissingStubError
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootic_client
 version: !ruby/object:Gem::Version
-  version: 0.0.31
+  version: 0.0.33
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-22 00:00:00.000000000 Z
+date: 2025-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -181,6 +181,7 @@ files:
 - lib/bootic_client/strategies/client_credentials.rb
 - lib/bootic_client/strategies/oauth2_strategy.rb
 - lib/bootic_client/strategies/strategy.rb
+- lib/bootic_client/stubbing.rb
 - lib/bootic_client/version.rb
 - lib/bootic_client/whiny_uri.rb
 - spec/authorized_strategy_spec.rb
@@ -198,6 +199,7 @@ files:
 - spec/safe_cache_serializer_spec.rb
 - spec/spec_helper.rb
 - spec/strategy_spec.rb
+- spec/stubbing_spec.rb
 - spec/whiny_uri_spec.rb
 homepage: https://developers.bootic.net
 licenses:
@@ -218,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: Official Ruby client for the Bootic API
@@ -238,4 +240,5 @@ test_files:
 - spec/safe_cache_serializer_spec.rb
 - spec/spec_helper.rb
 - spec/strategy_spec.rb
+- spec/stubbing_spec.rb
 - spec/whiny_uri_spec.rb