jbr 3.12.0 → 4.0.0

data/lib/graphql/throttled.rb

@@ -3,14 +3,5 @@ module GraphQL
   # itself. Worth telling apart: the same query is answered once the budget it is priced
   # against has refilled.
   class Throttled < Error
-    # @param message [String] what the endpoint said, with the numbers it said it with.
-    # @param cost [Hash] what it priced the query at, and the budget it priced it against.
-    def initialize(message, cost = {})
-      super message
-      @cost = cost
-    end
-
-    # @return [Hash] those numbers, in the endpoint's own words.
-    attr_reader :cost
   end
 end

data/lib/jbr/account.rb

@@ -1,23 +1,52 @@
 module Jbr
-  # The Jobber account a set of credentials belongs to.
-  class Account < Resource
-    # The query that reads the account behind the current credentials.
-    FIND = <<~GRAPHQL
-      { account { id name phone } }
-    GRAPHQL
+  # Credentials for one Jobber account, and the gateway to all they read or write.
+  class Account < Company::Account
+    include Querying, Refreshing
+    extend Authorizing
 
-    # @return [String, nil] the account ID.
-    def id = node['id']
+    # The query that reads the business behind the credentials, by the keys the vocabulary reads.
+    BUSINESS = "{ account { #{Company::Business.node_keys.join ' '} } }"
 
-    # @return [String, nil] what the business calls itself.
-    def name = node['name']
+    # Answers from {Jbr.mock} instead of Jobber once an app under test has touched it.
+    # @param credentials [Hash] see {#initialize}.
+    # @return [Account] credentials, mocked where the app asked for that.
+    def self.new(credentials = {})
+      Jbr.mocked? && self == Account ? Mock::Account.new(credentials) : super
+    end
 
-    # @return [String, nil] the number the business is reached on, as Jobber holds it.
-    def phone = node['phone']
+    # @param credentials [Hash] the tokens, their expiry, the account, when it went bad, and
+    #   the `store:` these are kept in, where processes share them. See {Refreshing}.
+    def initialize(credentials = {})
+      @access_token = credentials[:access_token]
+      @refresh_token = credentials[:refresh_token]
+      @expires_at = credentials[:expires_at]
+      @invalid_at = credentials[:invalid_at]
+      @account_id = credentials[:account_id]
+      @store = credentials[:store]
+    end
 
-  private
+    # The credentials as Jobber last gave them, plus the moment a refusal to refresh landed.
+    attr_reader :access_token, :refresh_token, :expires_at, :invalid_at
 
-    # Read once and remembered, whichever of the three is asked for first.
-    def node = @node = @node.presence || @oauth.query(FIND).fetch('account', {})
+    # @return [String, nil] ID of the account these credentials reach.
+    attr_accessor :account_id
+
+    # @return [Company::Business] business the credentials belong to, read from Jobber.
+    def business = Company::Business.new node: query(BUSINESS).fetch('account', {})
+
+    # @return [Jobs] jobs of the business.
+    def jobs = Jobs.new account: self
+
+    # @return [Visits] visits of the business.
+    def visits = Visits.new account: self
+
+    # @return [Quotes] quotes of the business, which Jobber alone lists.
+    def quotes = Quotes.new account: self
+
+    # @return [Leads] leads of the business.
+    def leads = Leads.new account: self
+
+    # @return [Invoices] invoices of the business, which Jobber alone answers for.
+    def invoices = Invoices.new account: self
   end
 end

data/lib/jbr/authorizing.rb

@@ -0,0 +1,43 @@
+module Jbr
+  # What the account class does before there are credentials: sends a Jobber user to authorize
+  # the app, and trades the code they come back with for a first set.
+  module Authorizing
+    # Where a Jobber user authorizes the app.
+    AUTHORIZE = 'https://api.getjobber.com/api/oauth/authorize'
+
+    # @param code [String] code Jobber sent to the redirect URI.
+    # @param redirect_uri [String] URI the code came back to.
+    # @return [Account] credentials for the account that authorized the app, its ID learned.
+    # @raise [Error] where Jobber will not take the code.
+    def create(code:, redirect_uri:)
+      credentials = post code: code, redirect_uri: redirect_uri, grant_type: 'authorization_code'
+      new(credentials).tap { |account| account.account_id = account.business.id }
+    end
+
+    # @param redirect_uri [String] where Jobber sends the user back to.
+    # @param state [String] what the app recognizes them by when they come back.
+    # @return [String] URL a Jobber user authorizes the app on.
+    def url_for(redirect_uri:, state:)
+      return Jbr.mock.oauth_url if Jbr.mocked?
+
+      uri = URI AUTHORIZE
+      uri.query = URI.encode_www_form redirect_uri: redirect_uri, state: state,
+        response_type: 'code', client_id: client_id
+      uri.to_s
+    end
+
+    # @return [String, nil] client ID the app is registered with Jobber as.
+    def client_id = ENV['JOBBER_CLIENT_ID']
+
+    # @return [String, nil] client secret the app proves itself to Jobber with.
+    def client_secret = ENV['JOBBER_CLIENT_SECRET']
+
+    # @param params [Hash] grant to exchange: a code, or a refresh token.
+    # @return [Hash] tokens Jobber answered, and the moment the access one expires.
+    def post(params = {})
+      return Mock::Account.post params if Jbr.mocked?
+
+      Token.post params.merge(client_id: client_id, client_secret: client_secret)
+    end
+  end
+end

data/lib/jbr/collection.rb

@@ -0,0 +1,14 @@
+module Jbr
+  # A list of records read through the credentials, with what it was asked to bring back beside
+  # each record and what it was narrowed to.
+  class Collection < Company::Collection
+    # @param account [Account] credentials to reach Jobber with.
+    # @param includes [Hash] what to bring back beside each record, by name.
+    # @param filter [Hash, nil] what the list was narrowed to, in the shape Jobber filters by.
+    def initialize(account:, includes: {}, filter: nil)
+      @account = account
+      @includes = includes
+      @filter = filter
+    end
+  end
+end

data/lib/jbr/collections/customers.rb

@@ -0,0 +1,54 @@
+module Jbr
+  # The clients on a Jobber account, reached by phone and opened where none answers to it.
+  class Customers < Reader
+    # The query that finds a client by phone, with the properties already on file.
+    LOOKUP = <<~GRAPHQL
+      query($searchTerm: String!) {
+        clientPhones(first: 1, searchTerm: $searchTerm) { nodes {
+          client { id updatedAt clientProperties { nodes { id address { #{Location::ADDRESS} } } } }
+        } }
+      }
+    GRAPHQL
+
+    # The mutation that opens a client, with a first property where an address is given.
+    CREATE = <<~GRAPHQL
+      mutation($input: ClientCreateInput!) {
+        clientCreate(input: $input) {
+          client { id clientProperties(first: 1) { nodes { id address { #{Location::ADDRESS} } } } }
+          userErrors { message }
+        }
+      }
+    GRAPHQL
+
+    # Reach the client answering to a number, opening one with the rest where Jobber has none.
+    # @param phone [String] number to match on, and to file a new client under.
+    # @param name [String] what to call them.
+    # @param surname [String, nil] their surname.
+    # @param email [String, nil] address they are written to.
+    # @param address [Hash] any of :street, :city, :state and :zip, the first place on file.
+    # @return [Customer] the client, with the places on their file.
+    def find_or_create_by(phone:, name:, surname:, email:, address:)
+      find_by(phone) || create(phone:, name:, surname:, email:, address:)
+    end
+
+  private
+
+    def find_by(phone)
+      output = @account.query LOOKUP, variables: { searchTerm: phone }
+      recent = output.dig('clientPhones', 'nodes').to_a.max_by do |node|
+        node.dig('client', 'updatedAt') || ''
+      end
+      Customer.new node: recent['client'] if recent
+    end
+
+    def create(phone:, name:, surname:, email:, address:)
+      input = { firstName: name, lastName: surname,
+                phones: [ { number: phone, primary: true } ],
+                emails: ([ { address: email, primary: true } ] if email.present?),
+                properties: ([ { address: Locations.address_from(address) } ] if address.present?),
+      }.compact
+      output = @account.query CREATE, variables: { input: input }
+      Customer.new node: output.dig('clientCreate', 'client')
+    end
+  end
+end

data/lib/jbr/collections/invoices.rb

@@ -0,0 +1,18 @@
+module Jbr
+  # The invoices on a Jobber account, each reached by the ID Jobber files it under.
+  class Invoices < Reader
+    # The query that reads one invoice, its total, its date and the job it bills.
+    FIND = <<~GRAPHQL
+      query($id: EncodedId!) {
+        invoice(id: $id) { id total invoiceStatus issuedDate jobs { nodes { id completedAt } } }
+      }
+    GRAPHQL
+
+    # @param id [String] Jobber ID of the invoice.
+    # @return [Invoice, nil] nil when Jobber has no invoice under that ID, or holds it as a draft.
+    def find(id)
+      node = @account.query(FIND, variables: { id: id })['invoice']
+      Invoice.new node: node if node && node['invoiceStatus'] != 'draft'
+    end
+  end
+end

data/lib/jbr/{jobs.rb → collections/jobs.rb}

@@ -1,19 +1,19 @@
 module Jbr
   # The jobs on a Jobber account, oldest first, walked a page at a time.
-  class Jobs < Resource
+  class Jobs < Collection
     include Includable, Listable
 
-    # What a job answers with wherever one is read, before anything it was asked to bring
-    # back with it.
-    FIELDS = 'id title instructions jobStatus total createdAt startAt completedAt ' \
+    # What a job answers with wherever one is read, before anything it was asked to bring back
+    # with it. Written by hand where the vocabulary's keys would not do: the quote nests.
+    FIELDS = 'id title instructions total createdAt startAt completedAt ' \
              'quote { id amounts { total } }'
 
     # Shadows Enumerable#find on purpose, the way Active Record does: a job is reached by the
     # ID Jobber files it under, not by asking every job on the account whether it is the one.
-    # @param id [String] the Jobber ID of the job.
+    # @param id [String] Jobber ID of the job.
     # @return [Job, nil] nil when Jobber has no job under that ID.
     def find(id)
-      node = @oauth.query(one, variables: { id: id })['job']
+      node = @account.query(one, variables: { id: id })['job']
       Job.new node: node if node
     end
 

data/lib/jbr/collections/leads.rb

@@ -0,0 +1,30 @@
+module Jbr
+  # The requests on a Jobber account's board: work somebody asked the business for.
+  class Leads < Company::Leads
+    # The mutation that opens a request against a client and a property.
+    CREATE = <<~GRAPHQL
+      mutation($input: RequestCreateInput!) {
+        requestCreate(input: $input) { request { id client { id } } userErrors { message } }
+      }
+    GRAPHQL
+
+    # @param account [Account] credentials to reach Jobber with.
+    def initialize(account:)
+      @account = account
+    end
+
+    # Files a request against the client answering to the phone and the property at the address,
+    # opening either where Jobber has none. The description is the request's title and the
+    # notes its instructions; Jobber has no source for a request, so that one is dropped.
+    # @return [Lead] the request, and the client it was opened against.
+    def create(name:, surname:, phone:, email:, address:, description:, notes:, source:)
+      customer = Customers.new(account: @account).find_or_create_by phone: phone,
+        name: name, surname: surname, email: email, address: address
+      location_id = Locations.new(account: @account).find_or_create_for customer, address
+      input = { clientId: customer.id, propertyId: location_id, title: description,
+                assessment: { instructions: notes }, }
+      output = @account.query CREATE, variables: { input: input }
+      Lead.new node: output.dig('requestCreate', 'request')
+    end
+  end
+end

data/lib/jbr/collections/locations.rb

@@ -0,0 +1,47 @@
+module Jbr
+  # The properties on a client's file, and the one a request is opened at.
+  class Locations < Reader
+    # The mutation that adds a property to a client already on file.
+    CREATE = <<~GRAPHQL
+      mutation($clientId: EncodedId!, $input: PropertyCreateInput!) {
+        propertyCreate(clientId: $clientId, input: $input) {
+          properties { id }
+          userErrors { message }
+        }
+      }
+    GRAPHQL
+
+    # What Jobber calls each address field, against what a caller passes.
+    FIELDS = { street1: :street, city: :city, province: :state, postalCode: :zip }
+
+    # The address as Jobber takes it, without the fields a caller left blank.
+    # @param fields [Hash] any of :street, :city, :state and :zip.
+    # @return [Hash] address, by Jobber's names.
+    def self.address_from(fields)
+      FIELDS.to_h { |jobber, ours| [ jobber, fields[ours] ] }.compact_blank
+    end
+
+    # Reach the property at an address on a client's file, adding one where none matches.
+    # @param customer [Customer] whose file, with the places already on it.
+    # @param address [Hash] any of :street, :city, :state and :zip.
+    # @return [String, nil] ID of the property, or nil where Jobber declined to add one.
+    def find_or_create_for(customer, address)
+      wanted = self.class.address_from address
+      match = customer.locations.find { |location| same_address? wanted, location }
+      match ? match.id : create(customer.id, wanted)
+    end
+
+  private
+
+    def create(client_id, address)
+      output = @account.query CREATE, variables: {
+        clientId: client_id, input: { properties: [ { address: address } ] },
+      }
+      output.dig 'propertyCreate', 'properties', 0, 'id'
+    end
+
+    def same_address?(wanted, location)
+      wanted[:street1] == location.street && wanted[:postalCode] == location.zip
+    end
+  end
+end

data/lib/jbr/collections/quotes.rb

@@ -0,0 +1,18 @@
+module Jbr
+  # The quotes on a Jobber account, each reached by the ID Jobber files it under.
+  class Quotes < Reader
+    # The query that reads one quote, what it comes to, and the request it came from.
+    FIND = <<~GRAPHQL
+      query($id: EncodedId!) {
+        quote(id: $id) { id amounts { total } request { id } }
+      }
+    GRAPHQL
+
+    # @param id [String] Jobber ID of the quote.
+    # @return [Quote, nil] nil when Jobber has no quote under that ID.
+    def find(id)
+      node = @account.query(FIND, variables: { id: id })['quote']
+      Quote.new node: node if node
+    end
+  end
+end

data/lib/jbr/{visits.rb → collections/visits.rb}

@@ -1,28 +1,28 @@
 module Jbr
   # The visits on a Jobber account, oldest first, walked a page at a time.
-  class Visits < Resource
-    include Includable, Listable
+  class Visits < Collection
+    include Listable
 
-    # What a visit answers with, before anything it was asked to bring back with it.
-    FIELDS = 'id title startAt endAt allDay clientConfirmed job { id }'
+    # What a visit answers with: the keys the vocabulary reads, and the job it belongs to.
+    FIELDS = "#{Visit.node_keys.join ' '} job { id }"
 
     # Shadows Enumerable#find on purpose, the way jobs do: a visit is reached by the ID Jobber
     # files it under, not by asking every visit on the account whether it is the one.
-    # @param id [String] the Jobber ID of the visit.
+    # @param id [String] Jobber ID of the visit.
     # @return [Visit, nil] nil when Jobber has no visit under that ID.
     def find(id)
-      node = @oauth.query(one, variables: { id: id })['visit']
+      node = @account.query(one, variables: { id: id })['visit']
       Visit.new node: node if node
     end
 
   private
 
-    def page = paged "#{FIELDS} #{selections}", PAGE
+    def page = paged FIELDS, PAGE
 
     def one
       <<~GRAPHQL
         query($id: EncodedId!) {
-          visit(id: $id) { #{FIELDS} #{selections} }
+          visit(id: $id) { #{FIELDS} }
         }
       GRAPHQL
     end

data/lib/jbr/error.rb

@@ -1,4 +1,4 @@
 module Jbr
   # An error raised when Jobber refuses a request.
-  Error = Class.new StandardError
+  Error = Class.new Company::Error
 end

data/lib/jbr/errors/throttled.rb

@@ -0,0 +1,6 @@
+module Jbr
+  # Jobber refusing a query over what it costs rather than over anything about the query. The
+  # bucket it is priced against refills, so the same question asked later is answered; the
+  # numbers it was refused with stay in the message.
+  Throttled = Class.new Company::Throttled
+end

data/lib/jbr/includable.rb

@@ -2,26 +2,24 @@ module Jbr
   # Extends a list of records with the chaining that says what to bring back beside them.
   # Nothing extra comes back unasked: a page costs what it carries.
   module Includable
-    # @param names [Array<Symbol, Hash>] :client, :line_items, :property, or
-    #   property: :client for the client whose file the place sits on.
-    # @return [Resource] the same list, asking Jobber for those too.
+    # @param names [Array<Symbol, Hash>] :lines, :location, or location: :customer for whose
+    #   place it is.
+    # @return [Collection] the same list, asking Jobber for those too.
     def includes(*names)
       named = names.each_with_object({}) do |name, all|
         name.is_a?(Hash) ? all.merge!(name) : all[name] = nil
       end
-      self.class.new oauth: @oauth, includes: @includes.merge(named)
+      self.class.new account: @account, includes: @includes.merge(named), filter: @filter
     end
 
   private
 
-    # What the includes ask Jobber for, in its own words.
     def selections = @includes.map { |name, nested| selection_of name, nested }.join ' '
 
     def selection_of(name, nested)
       case name
-        when :client then Cliental::SELECTION
-        when :line_items then LineItem::SELECTION
-        when :property then Properted.selection client: nested == :client
+        when :lines then Line::SELECTION
+        when :location then Location.selection customer: nested == :customer
       end
     end
   end

data/lib/jbr/listable.rb

@@ -3,11 +3,9 @@ module Jbr
   # a query by the page it asks for and by what every row of that page carries, so a list is
   # read either as records or as the IDs alone, each with a page sized to what it carries.
   module Listable
-    include Enumerable
-
     # Records a page, not forty and not a hundred: what an includes brings back is charged for
-    # on top of every row of it, so a page of jobs carrying their lines, their property and its
-    # client priced past what a bucket holds. Half the page costs half the query and loses
+    # on top of every row of it, so a page of jobs carrying their lines, their location and its
+    # customer priced past what a bucket holds. Half the page costs half the query and loses
     # nothing, since a walk simply reads more pages.
     PAGE = 20
 
@@ -19,42 +17,24 @@ module Jbr
     # starts, and a page is read only once the one before it runs out.
     def each(&) = walk(page).each(&)
 
-    # @param within [ActiveSupport::Duration, Numeric, nil] how far ahead to look, or nil for
-    #   as far ahead as the account is scheduled.
-    # @return [Listable] the same list, narrowed to what is scheduled from now on.
-    def upcoming(within = nil)
-      now = Time.now
-      narrowed after: now, before: (now + within if within)
-    end
-
-    # @param within [ActiveSupport::Duration, Numeric, nil] how far back to look, or nil for
-    #   as far back as the account goes.
-    # @return [Listable] the same list, narrowed to what started before now.
-    def past(within = nil)
-      now = Time.now
-      narrowed before: now, after: (now - within if within)
+    # The two halves of a schedule split at one moment rather than per page: read page by page
+    # the boundary would slide, and something could cross it unseen.
+    # @param from [Time, nil] the moment the window opens, or nothing for as far back as it goes.
+    # @param to [Time, nil] the moment the window closes, or nothing for as far ahead as it goes.
+    # @return [Collection] the same list, narrowed to what starts between the two.
+    def between(from, to)
+      bounds = { after: from&.iso8601, before: to&.iso8601 }.compact
+      self.class.new account: @account, includes: @includes, filter: { startAt: bounds }
     end
 
     # The ID Jobber files each record under, and nothing else about it: the cheapest question
     # an account can be walked with, and the one to ask where every record is then read on its
-    # own through {#find}.
+    # own through `find`.
     # @return [Array<String>] every ID in the list, every page of them read.
     def ids = walk(ids_page).map(&:id)
 
   private
 
-    # The two halves of a schedule, split at the moment they are asked for rather than per
-    # page: read page by page the boundary would slide, and something could cross it unseen.
-    # The same moment is the near end of a window, so the far end is measured from it too.
-    def narrowed(after: nil, before: nil)
-      bounds = { after: after&.iso8601, before: before&.iso8601 }.compact
-      self.class.new oauth: @oauth, includes: @includes, filter: { startAt: bounds }
-    end
-
-    # Whether a moment falls in the stretch of the schedule the list was narrowed to, for
-    # anything answering one without asking Jobber. A record with no moment at all is in an
-    # open-ended upcoming list, since nothing has started it, and in no window, since a window
-    # is a stretch it would have to have fallen in.
     def scheduled?(at)
       return true unless @filter
 
@@ -64,13 +44,11 @@ module Jbr
       (after.nil? || at >= Time.iso8601(after)) && (before.nil? || at <= Time.iso8601(before))
     end
 
-    # Every record a paged query answers, one at a time, a page read only once the one before
-    # it runs out. The filter is data: narrowed to nothing, the query narrows nothing.
     def walk(statement)
       Enumerator.new do |yielder|
         after = nil
         loop do
-          answered = @oauth.query statement, variables: { after: after, filter: @filter }.compact
+          answered = @account.query statement, variables: { after: after, filter: @filter }.compact
           current = answered.fetch field, {}
           current.fetch('nodes', []).each { |node| yielder << item(node) }
           break unless current.dig 'pageInfo', 'hasNextPage'

data/lib/jbr/mock/account.rb

@@ -1,15 +1,33 @@
 module Jbr
-  # The account that reads from {Jbr.mock} instead of Jobber.
+  # Credentials that answer from {Jbr.mock} instead of Jobber.
   class Mock::Account < Account
-    # @return [Object, nil] the values the app asked for, and 'account-01' for an ID it did not.
-    def id = node.fetch :id, 'account-01'
+    # @return [Company::Business] business the app named, under `account-01` where it named
+    #   no ID.
+    def business = Company::Business.new node: { id: 'account-01' }.merge(Jbr.mock.business.to_h)
 
-    def name = node[:name]
+    # @return [Mock::Jobs] jobs the app listed.
+    def jobs = Mock::Jobs.new account: self
 
-    def phone = node[:phone]
+    # @return [Mock::Visits] visits the app listed.
+    def visits = Mock::Visits.new account: self
 
-  private
+    # @return [Mock::Quotes] the one quote the app named.
+    def quotes = Mock::Quotes.new
 
-    def node = Jbr.mock.account.to_h
+    # @return [Mock::Leads] the one lead the app named.
+    def leads = Mock::Leads.new
+
+    # @return [Mock::Invoices] the one invoice the app named.
+    def invoices = Mock::Invoices.new
+
+    # Revoking a mocked token asks nobody.
+    def delete; end
+
+    # @return [Hash] canned credentials, unless the app asked for a refusal.
+    def self.post(_)
+      raise Error, Jbr.mock.oauth_error if Jbr.mock.oauth_error
+
+      { access_token: 'mock-token', refresh_token: 'mock-token', expires_at: Time.now + 3600 }
+    end
   end
 end

data/lib/jbr/mock/invoice.rb

@@ -1,18 +1,14 @@
 module Jbr
-  # An invoice that reads from {Jbr.mock} instead of Jobber.
+  # An invoice an app under test named, keyed by the readers' names rather than Jobber's.
   class Mock::Invoice < Invoice
-    # @return [Mock::Invoice] itself, carrying the mocked IDs and total.
-    def find(_)
-      @id = Jbr.mock.invoice[:id]
-      @job_id = Jbr.mock.invoice[:job_id]
-      @total = Jbr.mock.invoice[:total]
+    # The mock spells every key as the reader is named.
+    def self.keys = {}
 
-      self
-    end
+    # @return [Company::Job, nil] job the app named beside the invoice.
+    def job = record Company::Job, :job
 
-    # @return [Time, nil] the dates the app asked for.
-    def issued_at = Jbr.mock.invoice[:issued_at]
+  private
 
-    def completed_at = Jbr.mock.invoice[:completed_at]
+    def completed_at = time :completed_at
   end
 end

data/lib/jbr/mock/invoices.rb

@@ -0,0 +1,7 @@
+module Jbr
+  # The one invoice an app under test asked {Jbr.mock} to answer with.
+  class Mock::Invoices
+    # @return [Mock::Invoice, nil] invoice the app named, whatever ID is asked for.
+    def find(_id) = (Mock::Invoice.new node: Jbr.mock.invoice if Jbr.mock.invoice)
+  end
+end

data/lib/jbr/mock/jobs.rb

@@ -3,20 +3,24 @@ module Jbr
   # narrowing a list, and reading it as records or as IDs, is the same code a real one runs.
   class Mock::Jobs < Jobs
     # The job filed under that ID where the app listed one, and otherwise the single job it
-    # named — which is every app that mocks a lookup without mocking a list.
-    # @return [Mock::Job] the job asked for.
-    def find(id) = Mock::Job.new node: listed(id) || Jbr.mock.job
+    # named, which is every app that mocks a lookup without mocking a list.
+    # @param id [String] ID the app filed the job under.
+    # @return [Company::Job, nil] job asked for, nil where the app named none.
+    def find(id)
+      node = listed(id) || Jbr.mock.job
+      Company::Job.new node: node if node
+    end
 
   private
 
     def walk(_statement)
-      Enumerator.new { |yielder| selected.each { |job| yielder << Mock::Job.new(node: job) } }
+      Enumerator.new do |yielder|
+        selected.each { |node| yielder << Company::Job.new(node: node) }
+      end
     end
 
     def selected = Jbr.mock.jobs.select { |job| scheduled? job[:scheduled_at] }
 
-    # Only a real list is looked through: an app that mocked the list as something raising
-    # was mocking the walk failing, and a lookup is a question of its own.
     def listed(id) = (Jbr.mock.jobs.find { |job| job[:id] == id } if Jbr.mock.jobs.is_a? Array)
   end
 end

data/lib/jbr/mock/leads.rb

@@ -0,0 +1,7 @@
+module Jbr
+  # The one lead an app under test asked {Jbr.mock} to answer with.
+  class Mock::Leads
+    # @return [Company::Lead] lead the app named, whatever was asked to be filed.
+    def create(**) = Company::Lead.new node: Jbr.mock.lead.to_h
+  end
+end

data/lib/jbr/mock/quote.rb

@@ -1,12 +1,7 @@
 module Jbr
-  # A quote that reads from {Jbr.mock} instead of Jobber.
+  # A quote an app under test named, its lead under the mock's own key rather than Jobber's.
   class Mock::Quote < Quote
-    # @return [Mock::Quote] itself, carrying the mocked IDs.
-    def find(_)
-      @id = Jbr.mock.quote[:id]
-      @request_id = Jbr.mock.quote[:request_id]
-
-      self
-    end
+    # @return [Company::Lead, nil] lead the app named beside the quote.
+    def lead = record Company::Lead, :lead
   end
 end