aptible-resource 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5900b6d991cbb35f8f24586a4159c5e20a42bf7eb084c896a1e03d2fd88d393
-  data.tar.gz: 3bc765fa4be89779be7e70e90d64827281057a1857b2fa6d6bdf7d6473561c19
+  metadata.gz: 0be9a27c339a79cef6ee77d5388d8baa8a2eb46fb9ffa3757c9a6bd7c3805271
+  data.tar.gz: 5806ba6232617393d0c6ccd83eda9ae8f7bd9a988623abbe9d63e5ed841df9be
 SHA512:
-  metadata.gz: 8829126f5c77257f43619f14a8db713c4fe16ad7c63c9d0823047aca7fd3e0d0790238ee677d21648b9cf5e8e55611d062213aa631d4d6053436a6f3254d84e3
-  data.tar.gz: c3b5c7229ca716235b946402fc92b3b6295b3707e05a762e988956e45c5d32080fcd11fd6ef18c405bb3526ec941bc8b389281a8da9045f8b51e40502d90d5df
+  metadata.gz: b7fd6a01fcb9e3f5389b03307046d1db07789932a8eaa5ab5a20cddfc6cb7bf49ff44553b6eb5661d358721bfea0a8265c5fdb026eaa50d18e4c38e9e0c64387
+  data.tar.gz: 8c06bb2636c1ad3948b3e30135cb6a16e7f65926f7f4111a44595bf978f5f3913adabd7fda7ffb92ebe25c87169934b7371956c9935e0fc2e4d736ff142d2ca3

data/.github/workflows/release.yml

@@ -0,0 +1,26 @@
+on:
+  release:
+    types: [published]
+
+jobs:
+  push:
+    name: Push gem to RubyGems.org
+    runs-on: ubuntu-latest
+
+    permissions: 
+        id-token: write
+        contents: write
+
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8
+        with:
+          persist-credentials: false
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@211ffaaa5f8dda97e9e8bca4e70d0fbaf2f8c41c
+        with:
+          bundler-cache: false
+          ruby-version: "3.3"
+
+      - run: bundle install
+
+      - uses: rubygems/release-gem@1c162a739e8b4cb21a676e97b087e8268d8fc40b

data/.github/workflows/test.yml

@@ -15,20 +15,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        RUBY_VERSION: [2.2, 2.3, 2.6, 2.7]
+        RUBY_VERSION: [2.3, 2.4, 2.5, 2.6, 2.7, 3.1, 3.2, 3.3, 3.4]
+    env:
+      RUBY_VERSION: ${{ matrix.RUBY_VERSION }}
     steps:
       - name: Check out code
         uses: actions/checkout@v4
 
-      - name: Install Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.RUBY_VERSION }}
-          bundler: 1.17.3
-          bundler-cache: true
-
       - name: Rubocop
-        run: bundle exec rake rubocop
+        run: make lint
 
       - name: Test
-        run: bundle exec rspec
+        run: make test

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+/docker/ruby-*/

data/Dockerfile

@@ -0,0 +1,22 @@
+ARG RUBY_VERSION=2.3.1
+FROM ruby:${RUBY_VERSION}
+
+ARG BUNDLER_VERSION=1.17.3
+ENV BUNDLER_VERSION=${BUNDLER_VERSION}
+RUN if [ "${BUNDLER_VERSION}" != "" ] ; then \
+      gem install bundler -v "${BUNDLER_VERSION}" ; \
+    fi
+
+WORKDIR /app
+COPY Gemfile /app/
+COPY aptible-resource.gemspec /app/
+RUN mkdir -p /app/lib/aptible/resource/
+COPY lib/aptible/resource/version.rb /app/lib/aptible/resource/
+RUN mkdir -p /app/lib/hyper_resource/
+COPY lib/hyper_resource/version.rb /app/lib/hyper_resource/
+
+RUN bundle install
+
+COPY . /app
+
+CMD ["bash"]

data/Makefile

@@ -0,0 +1,74 @@
+
+export COMPOSE_IGNORE_ORPHANS ?= true
+export RUBY_VERSION ?= 2.3.1
+RUBY_VERSION_MAJOR = $(word 1,$(subst ., ,$(RUBY_VERSION)))
+RUBY_VERSION_MINOR = $(word 2,$(subst ., ,$(RUBY_VERSION)))
+export BUNDLER_VERSION ?=
+ifeq ($(BUNDLER_VERSION),)
+ifeq ($(RUBY_VERSION_MAJOR),2)
+# Use old bundler for Ruby 2.3-2.6; Ruby 2.7 needs bundler 2.x to avoid resolver bugs
+ifeq ($(RUBY_VERSION_MINOR),7)
+export BUNDLER_VERSION = 2.4.22
+else
+export BUNDLER_VERSION = 1.17.3
+endif
+endif
+endif
+PROJECT_NAME = $(shell ls *.gemspec | sed 's/\.gemspec//')
+export COMPOSE_PROJECT_NAME ?= $(PROJECT_NAME)-$(subst .,_,$(RUBY_VERSION))
+
+default: help
+
+## Show this help message
+help:
+	@echo "\n\033[1;34mAvailable targets:\033[0m\n"
+	@awk 'BEGIN {FS = ":"; prev = ""} \
+					/^## / {prev = substr($$0, 4); next} \
+					/^[a-zA-Z_-]+:/ {if (prev != "") printf "  \033[1;36m%-20s\033[0m %s\n", $$1, prev; prev = ""} \
+					{prev = ""}' $(MAKEFILE_LIST) | sort
+	@echo
+
+BUILD_ARGS ?=
+## Build and pull docker compose images
+build: gemfile-lock
+	docker compose build --pull $(BUILD_ARGS)
+
+## Create a Gemfile.lock specific to the container (i.e., for the ruby version)
+gemfile-lock:
+	mkdir -pv ./docker/ruby-$(RUBY_VERSION)/ && \
+	echo '' > ./docker/ruby-$(RUBY_VERSION)/Gemfile.lock
+
+## Open shell in a docker container, supports CMD=
+bash: build
+	$(MAKE) run CMD=bash
+
+CMD ?= bash
+## Run command in a docker container, supports CMD=
+run:
+	docker compose run --rm runner $(CMD)
+
+## Run tests in a docker container, supports ARGS=
+test: build
+	$(MAKE) test-direct ARGS="$(ARGS)"
+
+## Run tests in a docker container without building, supports ARGS=
+test-direct:
+	$(MAKE) run CMD="bundle exec rspec $(ARGS)"
+
+## Run rubocop in a docker container, supports ARGS=
+lint: build
+	$(MAKE) lint-direct ARGS="$(ARGS)"
+
+## Run rubocop in a docker container without building, supports ARGS=
+lint-direct:
+	$(MAKE) run CMD="bundle exec rake rubocop $(ARGS)"
+
+## Clean up docker compose resources
+clean: clean-gemfile-lock
+	docker compose down --remove-orphans --volumes
+
+## Clean up the container specific Gemfile.lock
+clean-gemfile-lock:
+	rm -v ./docker/ruby-$(RUBY_VERSION)/Gemfile.lock ||:
+
+.PHONY: build bash test

data/aptible-resource.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'aptible-tasks'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'rake', '< 11.0'
-  spec.add_development_dependency 'rspec', '~> 2.0'
-  spec.add_development_dependency 'webmock', '~> 2.3.2'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'webmock', '~> 3.0'
 end

data/docker-compose.yml

@@ -0,0 +1,12 @@
+services:
+  runner:
+    build:
+      context: .
+      args:
+        RUBY_VERSION: ${RUBY_VERSION:-2.3.1}
+        BUNDLER_VERSION: ${BUNDLER_VERSION:-}
+    volumes:
+      - type: bind
+        source: .
+        target: /app
+      - ./docker/ruby-${RUBY_VERSION}/Gemfile.lock:/app/Gemfile.lock

data/lib/aptible/resource/version.rb

@@ -1,5 +1,5 @@
 module Aptible
   module Resource
-    VERSION = '1.1.3'.freeze
+    VERSION = '1.1.4'.freeze
   end
 end

data/spec/aptible/resource/base_spec.rb

@@ -5,42 +5,38 @@ require 'spec_helper'
 describe Aptible::Resource::Base do
   let(:hyperresource_exception) { HyperResource::ResponseError.new('403') }
   let(:error_response) { double 'Faraday::Response' }
-  before { hyperresource_exception.stub(:response) { error_response } }
+  let(:expected_root_url) { 'https://resource.example.com' }
   before do
-    error_response.stub(:body) { { message: 'Forbidden' }.to_json }
-    error_response.stub(:status) { 403 }
+    allow(hyperresource_exception).to receive(:response)
+      .and_return(error_response)
+  end
+  before do
+    allow(error_response).to receive(:body)
+      .and_return({ message: 'Forbidden' }.to_json)
+    allow(error_response).to receive(:status).and_return(403)
   end
 
   shared_context 'paginated collection' do
     let(:urls) { ['/mainframes', '/mainframes?page=1'] }
-    let(:calls) { [] }
+    let(:expected_calls) do
+      urls.map { |u| [:get, "#{expected_root_url}#{u}"] }
+    end
+    let(:expected_record_ids) do
+      urls.map.with_index { |_, i| i + 1 }
+    end
 
     before do
-      pages = {}
-
       urls.each_with_index do |url, idx|
-        collection = double("Collection for #{url}")
-        links = {}
-
-        allow(collection).to receive(:entries).and_return(["At #{url}"])
-        allow(collection).to receive(:links).and_return(links)
-
-        next_url = urls[idx + 1]
-        if next_url
-          links['next'] = HyperResource::Link.new(nil, 'href' => next_url)
-        end
-
-        pages[url] = collection
-      end
-
-      [Api, Api::Mainframe].each do |klass|
-        allow_any_instance_of(klass).to receive(:find_by_url) do |_, u, _|
-          calls << u
-          page = pages[u]
-          raise "Accessed unexpected URL #{u}" if page.nil?
-
-          page
-        end
+        next_href = {}
+        next_href = { next: { href: urls[idx + 1] } } if urls[idx + 1]
+        stub_request(:get, "#{expected_root_url}#{url}")
+          .to_return(
+            body: {
+              _embedded: { mainframes: [{ id: idx + 1, _type: 'mainframe' }] },
+              _links: next_href
+            }.to_json,
+            status: 200
+          )
       end
     end
   end
@@ -54,6 +50,14 @@ describe Aptible::Resource::Base do
     end
   end
 
+  describe '.root_url' do
+    it 'should have a root_url with no trailing slash' do
+      the_url = Api.new.root_url
+      expect(the_url).not_to end_with('/')
+      expect(the_url).to eq(expected_root_url)
+    end
+  end
+
   describe '.find' do
     it 'should find' do
       stub_request(
@@ -89,9 +93,10 @@ describe Aptible::Resource::Base do
       let(:collection) { double 'Api' }
 
       before do
-        collection.stub(:entries) { [mainframe] }
-        collection.stub(:links) { {} }
-        Api::Mainframe.any_instance.stub(:find_by_url) { collection }
+        allow(collection).to receive(:entries).and_return([mainframe])
+        allow(collection).to receive(:links).and_return({})
+        allow_any_instance_of(Api::Mainframe).to receive(:find_by_url)
+          .and_return(collection)
       end
 
       it 'should be an array' do
@@ -116,9 +121,12 @@ describe Aptible::Resource::Base do
       it 'should collect entries from all pages' do
         records = Api::Mainframe.all
         expect(records.size).to eq(2)
-        expect(records.first).to eq('At /mainframes')
-        expect(records.second).to eq('At /mainframes?page=1')
-        expect(calls).to eq(urls)
+        expect(records).to all(be_a_kind_of(Api::Mainframe))
+        expect(records.first.id).to eq(1)
+        expect(records.second.id).to eq(2)
+        expected_calls.each do |args|
+          expect(WebMock).to have_requested(*args)
+        end
       end
 
       it "should return an empty list for a URL that doesn't exist" do
@@ -135,18 +143,25 @@ describe Aptible::Resource::Base do
       pages = 0
       Api::Mainframe.each_page { pages += 1 }
       expect(pages).to eq(2)
-      expect(calls).to eq(urls)
+      expected_calls.each do |args|
+        expect(WebMock).to have_requested(*args)
+      end
     end
 
     it 'should find all records' do
-      records = ['At /mainframes', 'At /mainframes?page=1']
-      Api::Mainframe.each_page { |p| expect(p).to eq([records.shift]) }
-      expect(calls).to eq(urls)
+      Api::Mainframe.each_page do |p|
+        expect(p).to all(be_a_kind_of(Api::Mainframe))
+        expect(p.map(&:id)).to eq([expected_record_ids.shift])
+      end
+      expected_calls.each do |args|
+        expect(WebMock).to have_requested(*args)
+      end
     end
 
     it 'should not access more URLs if the consumer breaks' do
       Api::Mainframe.each_page { break }
-      expect(calls).to eq(['/mainframes'])
+      expect(WebMock).to have_requested(*expected_calls.first)
+      expect(WebMock).not_to have_requested(*expected_calls.second)
     end
 
     it 'should return an enum if no block is given' do
@@ -154,7 +169,9 @@ describe Aptible::Resource::Base do
       pages = 0
       e.each { pages += 1 }
       expect(pages).to eq(2)
-      expect(calls).to eq(urls)
+      expected_calls.each do |args|
+        expect(WebMock).to have_requested(*args)
+      end
     end
   end
 
@@ -162,29 +179,34 @@ describe Aptible::Resource::Base do
     let(:mainframe) { Api::Mainframe.new }
     let(:mainframes_link) { HyperResource::Link.new(href: '/mainframes') }
 
-    before { Api.any_instance.stub(:mainframes) { mainframes_link } }
-    before { mainframes_link.stub(:create) { mainframe } }
+    before do
+      allow_any_instance_of(Api).to receive(:mainframes)
+        .and_return(mainframes_link)
+    end
+    before { allow(mainframes_link).to receive(:create).and_return(mainframe) }
 
     it 'should create a new top-level resource' do
-      mainframes_link.stub(:create) { mainframe }
+      allow(mainframes_link).to receive(:create).and_return(mainframe)
       expect(mainframes_link).to receive(:create)
       Api::Mainframe.create(foo: 'bar')
     end
 
     it 'should populate #errors in the event of an error' do
-      mainframes_link.stub(:create) { raise hyperresource_exception }
+      allow(mainframes_link).to receive(:create)
+        .and_raise(hyperresource_exception)
       mainframe = Api::Mainframe.create
       expect(mainframe.errors.messages).to eq(base: 'Forbidden')
       expect(mainframe.errors.full_messages).to eq(['Forbidden'])
     end
 
     it 'should return a Base-classed resource on error' do
-      mainframes_link.stub(:create) { raise hyperresource_exception }
+      allow(mainframes_link).to receive(:create)
+        .and_raise(hyperresource_exception)
       expect(Api::Mainframe.create).to be_a Api::Mainframe
     end
 
     it 'should return the object in the event of successful creation' do
-      mainframes_link.stub(:create) { mainframe }
+      allow(mainframes_link).to receive(:create).and_return(mainframe)
       expect(Api::Mainframe.create).to eq mainframe
     end
   end
@@ -193,18 +215,22 @@ describe Aptible::Resource::Base do
     let(:mainframe) { Api::Mainframe.new }
     let(:mainframes_link) { HyperResource::Link.new(href: '/mainframes') }
 
-    before { Api.any_instance.stub(:mainframes) { mainframes_link } }
-    before { mainframes_link.stub(:create) { mainframe } }
+    before do
+      allow_any_instance_of(Api).to receive(:mainframes)
+        .and_return(mainframes_link)
+    end
+    before { allow(mainframes_link).to receive(:create).and_return(mainframe) }
 
     it 'should pass through any exceptions' do
-      mainframes_link.stub(:create) { raise hyperresource_exception }
+      allow(mainframes_link).to receive(:create)
+        .and_raise(hyperresource_exception)
       expect do
         Api::Mainframe.create!
       end.to raise_error HyperResource::ResponseError
     end
 
     it 'should return the object in the event of successful creation' do
-      mainframes_link.stub(:create) { mainframe }
+      allow(mainframes_link).to receive(:create).and_return(mainframe)
       expect(Api::Mainframe.create!).to eq mainframe
     end
   end
@@ -222,20 +248,20 @@ describe Aptible::Resource::Base do
   describe '#bearer_token' do
     it 'should accept an Aptible::Resource::Token' do
       token = Api::Token.new
-      token.stub(:access_token) { 'aptible_auth_token' }
-      subject.stub(:token) { token }
+      allow(token).to receive(:access_token).and_return('aptible_auth_token')
+      allow(subject).to receive(:token).and_return(token)
       expect(subject.bearer_token).to eq token.access_token
     end
 
     it 'should accept a Fridge::AccessToken' do
       token = Fridge::AccessToken.new
-      token.stub(:to_s) { 'fridge_access_token' }
-      subject.stub(:token) { token }
+      allow(token).to receive(:to_s).and_return('fridge_access_token')
+      allow(subject).to receive(:token).and_return(token)
       expect(subject.bearer_token).to eq token.to_s
     end
 
     it 'should accept a String' do
-      subject.stub(:token) { 'token' }
+      allow(subject).to receive(:token).and_return('token')
       expect(subject.bearer_token).to eq 'token'
     end
   end
@@ -250,26 +276,29 @@ describe Aptible::Resource::Base do
 
   describe '#update' do
     it 'should populate #errors in the event of an error' do
-      HyperResource.any_instance.stub(:put) { raise hyperresource_exception }
+      allow_any_instance_of(HyperResource).to receive(:put)
+        .and_raise(hyperresource_exception)
       subject.update({})
       expect(subject.errors.messages).to eq(base: 'Forbidden')
       expect(subject.errors.full_messages).to eq(['Forbidden'])
     end
 
     it 'should return false in the event of an error' do
-      HyperResource.any_instance.stub(:put) { raise hyperresource_exception }
+      allow_any_instance_of(HyperResource).to receive(:put)
+        .and_raise(hyperresource_exception)
       expect(subject.update({})).to eq false
     end
 
     it 'should return the object in the event of a successful update' do
-      HyperResource.any_instance.stub(:put) { subject }
+      allow_any_instance_of(HyperResource).to receive(:put).and_return(subject)
       expect(subject.update({})).to eq subject
     end
   end
 
   describe '#update!' do
     it 'should populate #errors in the event of an error' do
-      HyperResource.any_instance.stub(:put) { raise hyperresource_exception }
+      allow_any_instance_of(HyperResource).to receive(:put)
+        .and_raise(hyperresource_exception)
       begin
         subject.update!({})
       rescue StandardError
@@ -281,14 +310,15 @@ describe Aptible::Resource::Base do
     end
 
     it 'should pass through any exceptions' do
-      HyperResource.any_instance.stub(:put) { raise hyperresource_exception }
+      allow_any_instance_of(HyperResource).to receive(:put)
+        .and_raise(hyperresource_exception)
       expect do
         subject.update!({})
       end.to raise_error HyperResource::ResponseError
     end
 
     it 'should return the object in the event of a successful update' do
-      HyperResource.any_instance.stub(:put) { subject }
+      allow_any_instance_of(HyperResource).to receive(:put).and_return(subject)
       expect(subject.update!({})).to eq subject
     end
   end
@@ -309,50 +339,61 @@ describe Aptible::Resource::Base do
     let(:mainframe) { Api::Mainframe.new }
     let(:mainframes_link) { HyperResource::Link.new(href: '/mainframes') }
 
-    before { subject.stub(:loaded) { true } }
-    before { subject.stub(:links) { { mainframes: mainframes_link } } }
-    before { mainframes_link.stub(:entries) { [mainframe] } }
-    before { mainframes_link.stub(:base_href) { '/mainframes' } }
+    before { allow(subject).to receive(:loaded).and_return(true) }
+    before do
+      allow(subject).to receive(:links)
+        .and_return(mainframes: mainframes_link)
+    end
+    before do
+      allow(mainframes_link).to receive(:entries).and_return([mainframe])
+    end
+    before do
+      allow(mainframes_link).to receive(:base_href).and_return('/mainframes')
+    end
 
     describe '#create_#{relation}' do
       it 'should populate #errors in the event of an error' do
-        mainframes_link.stub(:create) { raise hyperresource_exception }
+        allow(mainframes_link).to receive(:create)
+          .and_raise(hyperresource_exception)
         mainframe = subject.create_mainframe({})
         expect(mainframe.errors.messages).to eq(base: 'Forbidden')
         expect(mainframe.errors.full_messages).to eq(['Forbidden'])
       end
 
       it 'should return a Base-classed resource on error' do
-        mainframes_link.stub(:create) { raise hyperresource_exception }
+        allow(mainframes_link).to receive(:create)
+          .and_raise(hyperresource_exception)
         expect(subject.create_mainframe.class).to eq Aptible::Resource::Base
       end
 
       it 'should have errors present on error' do
-        mainframes_link.stub(:create) { raise hyperresource_exception }
+        allow(mainframes_link).to receive(:create)
+          .and_raise(hyperresource_exception)
         expect(subject.create_mainframe.errors.any?).to be true
       end
 
       it 'should return the object in the event of successful creation' do
-        mainframes_link.stub(:create) { mainframe }
+        allow(mainframes_link).to receive(:create).and_return(mainframe)
         expect(subject.create_mainframe({})).to eq mainframe
       end
 
       it 'should have no errors on successful creation' do
-        mainframes_link.stub(:create) { mainframe }
+        allow(mainframes_link).to receive(:create).and_return(mainframe)
         expect(subject.create_mainframe.errors.any?).to be false
       end
     end
 
     describe '#create_#{relation}!' do
       it 'should pass through any exceptions' do
-        mainframes_link.stub(:create) { raise hyperresource_exception }
+        allow(mainframes_link).to receive(:create)
+          .and_raise(hyperresource_exception)
         expect do
           subject.create_mainframe!({})
         end.to raise_error HyperResource::ResponseError
       end
 
       it 'should return the object in the event of successful creation' do
-        mainframes_link.stub(:create) { mainframe }
+        allow(mainframes_link).to receive(:create).and_return(mainframe)
         expect(subject.create_mainframe!({})).to eq mainframe
       end
     end
@@ -362,11 +403,13 @@ describe Aptible::Resource::Base do
 
       it 'should return all records' do
         records = subject.mainframes
-
         expect(records.size).to eq(2)
-        expect(records.first).to eq('At /mainframes')
-        expect(records.second).to eq('At /mainframes?page=1')
-        expect(calls).to eq(urls)
+        expect(records).to all(be_a_kind_of(Api::Mainframe))
+        expect(records.first.id).to eq(1)
+        expect(records.second.id).to eq(2)
+        expected_calls.each do |args|
+          expect(WebMock).to have_requested(*args)
+        end
       end
     end
 
@@ -375,17 +418,20 @@ describe Aptible::Resource::Base do
 
       it 'should iterate over all records' do
         records = []
-        subject.each_mainframe { |mainframe| records << mainframe }
-
+        subject.each_mainframe { |m| records << m }
         expect(records.size).to eq(2)
-        expect(records.first).to eq('At /mainframes')
-        expect(records.second).to eq('At /mainframes?page=1')
-        expect(calls).to eq(urls)
+        expect(records).to all(be_a_kind_of(Api::Mainframe))
+        expect(records.first.id).to eq(1)
+        expect(records.second.id).to eq(2)
+        expected_calls.each do |args|
+          expect(WebMock).to have_requested(*args)
+        end
       end
 
       it 'should stop iterating when the consumer breaks' do
         subject.each_mainframe { |_| break }
-        expect(calls).to eq([urls[0]])
+        expect(WebMock).to have_requested(*expected_calls.first)
+        expect(WebMock).not_to have_requested(*expected_calls.second)
       end
 
       it 'should return an enum if no block is given' do
@@ -393,7 +439,10 @@ describe Aptible::Resource::Base do
         records = []
         e.each { |m| records << m }
         expect(records.size).to eq(2)
-        expect(calls).to eq(urls)
+        expect(records).to all(be_a_kind_of(Api::Mainframe))
+        expected_calls.each do |args|
+          expect(WebMock).to have_requested(*args)
+        end
       end
     end
   end
@@ -402,10 +451,13 @@ describe Aptible::Resource::Base do
     let(:m1) { Api::Mainframe.new }
     let(:m2) { Api::Mainframe.new }
 
-    before { subject.stub(:loaded) { true } }
-    before { subject.stub(:objects) { { embedded_mainframes: [m1, m2] } } }
-    before { m1.stub(id: 1) }
-    before { m2.stub(id: 2) }
+    before { allow(subject).to receive(:loaded).and_return(true) }
+    before do
+      allow(subject).to receive(:objects)
+        .and_return(embedded_mainframes: [m1, m2])
+    end
+    before { allow(m1).to receive(:id).and_return(1) }
+    before { allow(m2).to receive(:id).and_return(2) }
 
     describe '#{relation}s' do
       it 'should return all records' do
@@ -447,25 +499,27 @@ describe Aptible::Resource::Base do
 
     it 'should return the raw attribute' do
       Api.field :foo, type: String
-      subject.stub(:attributes) { { foo: 'bar' } }
+      allow(subject).to receive(:attributes).and_return(foo: 'bar')
       expect(subject.foo).to eq 'bar'
     end
 
     it 'should parse the attribute if DateTime' do
       Api.field :created_at, type: DateTime
-      subject.stub(:attributes) { { created_at: Time.now.to_json } }
+      allow(subject).to receive(:attributes)
+        .and_return(created_at: Time.now.to_json)
       expect(subject.created_at).to be_a DateTime
     end
 
     it 'should parse the attribute if Time' do
       Api.field :created_at, type: Time
-      subject.stub(:attributes) { { created_at: Time.now.to_json } }
+      allow(subject).to receive(:attributes)
+        .and_return(created_at: Time.now.to_json)
       expect(subject.created_at).to be_a Time
     end
 
     it 'should add a ? helper if Boolean' do
       Api.field :awesome, type: Aptible::Resource::Boolean
-      subject.stub(:attributes) { { awesome: 'true' } }
+      allow(subject).to receive(:attributes).and_return(awesome: 'true')
       expect(subject.awesome?).to be true
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aptible-resource
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Frank Macreery
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-05 00:00:00.000000000 Z
+date: 2025-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -140,44 +140,44 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.2
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.2
+        version: '3.0'
 description: Foundation classes for Aptible resource server gems
 email:
 - frank@macreery.com
@@ -186,16 +186,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/CODEOWNERS"
+- ".github/workflows/release.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- Dockerfile
 - Gemfile
 - LICENSE.md
+- Makefile
 - README.md
 - Rakefile
 - SECURITY.md
 - aptible-resource.gemspec
+- docker-compose.yml
 - lib/aptible/resource.rb
 - lib/aptible/resource/adapter.rb
 - lib/aptible/resource/base.rb
@@ -228,7 +232,7 @@ homepage: https://github.com/aptible/aptible-resource
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -243,8 +247,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Foundation classes for Aptible resource server gems
 test_files: