jira-ruby 2.1.3

data/spec/integration/user_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe JIRA::Resource::User do
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+    let(:key) { 'admin' }
+
+    let(:expected_attributes) do
+      {
+        'self' => 'http://localhost:2990/jira/rest/api/2/user?username=admin',
+        'name' => key,
+        'emailAddress' => 'admin@example.com'
+      }
+    end
+
+    it_should_behave_like 'a resource'
+    it_should_behave_like 'a resource with a singular GET endpoint'
+
+    describe '#all' do
+      let(:client) do
+        client = double(options: { rest_base_path: '/jira/rest/api/2' })
+        allow(client).to receive(:get).with('/rest/api/2/user/search?username=_&maxResults=1000').and_return(JIRA::Resource::UserFactory.new(client))
+        client
+      end
+
+      before do
+        allow(client).to receive(:get)
+          .with('/rest/api/2/user/search?username=_&maxResults=1000') { OpenStruct.new(body: '["User1"]') }
+        allow(client).to receive_message_chain(:User, :build).with('users') { [] }
+      end
+
+      it 'gets users with maxResults of 1000' do
+        expect(client).to receive(:get).with('/rest/api/2/user/search?username=_&maxResults=1000')
+        expect(client).to receive_message_chain(:User, :build).with('User1')
+        JIRA::Resource::User.all(client)
+      end
+    end
+  end
+end

data/spec/integration/version_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Version do
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+    let(:key) { '10000' }
+
+    let(:expected_attributes) do
+      {
+        'self' => 'http://localhost:2990/jira/rest/api/2/version/10000',
+        'id'   => key,
+        'description' => 'Initial version'
+      }
+    end
+
+    let(:attributes_for_post) do
+      { 'name' => '2.0', 'project' => 'SAMPLEPROJECT' }
+    end
+    let(:expected_attributes_from_post) do
+      { 'id' => '10001', 'name' => '2.0' }
+    end
+
+    let(:attributes_for_put) do
+      { 'name' => '2.0.0' }
+    end
+    let(:expected_attributes_from_put) do
+      { 'id' => '10000', 'name' => '2.0.0' }
+    end
+
+    it_should_behave_like 'a resource'
+    it_should_behave_like 'a resource with a singular GET endpoint'
+    it_should_behave_like 'a resource with a DELETE endpoint'
+    it_should_behave_like 'a resource with a POST endpoint'
+    it_should_behave_like 'a resource with a PUT endpoint'
+    it_should_behave_like 'a resource with a PUT endpoint that rejects invalid fields'
+  end
+end

data/spec/integration/watcher_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Watcher do
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+    let(:target) { JIRA::Resource::Watcher.new(client, attrs: { 'id' => '99999' }, issue_id: '10002') }
+
+    let(:belongs_to) do
+      JIRA::Resource::Issue.new(client, attrs: {
+                                  'id' => '10002',
+                                  'fields' => {
+                                    'comment' => { 'comments' => [] }
+                                  }
+                                })
+    end
+
+    let(:expected_attributes) do
+      {
+        'self' => 'http://localhost:2990/jira/rest/api/2/issue/10002/watchers',
+        "isWatching": false,
+        "watchCount": 1,
+        "watchers": [
+          {
+            "self": 'http://www.example.com/jira/rest/api/2/user?username=admin',
+            "name": 'admin',
+            "displayName": 'admin',
+            "active": false
+          }
+        ]
+      }
+    end
+
+    describe 'watchers' do
+      before(:each) do
+        stub_request(:get, site_url + '/jira/rest/api/2/issue/10002')
+          .to_return(status: 200, body: get_mock_response('issue/10002.json'))
+
+        stub_request(:get, site_url + '/jira/rest/api/2/issue/10002/watchers')
+          .to_return(status: 200, body: get_mock_response('issue/10002/watchers.json'))
+
+        stub_request(:post, site_url + '/jira/rest/api/2/issue/10002/watchers')
+          .to_return(status: 204, body: nil)
+      end
+
+      it 'should returns all the watchers' do
+        issue = client.Issue.find('10002')
+        watchers = client.Watcher.all(options = { issue: issue })
+        expect(watchers.length).to eq(1)
+      end
+
+      it 'should add a watcher' do
+        issue = client.Issue.find('10002')
+        watcher = JIRA::Resource::Watcher.new(client, issue: issue)
+        user_id = "tester"
+        watcher.save!(user_id)
+      end
+    end
+
+  end
+end

data/spec/integration/webhook.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Webhook do
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+    let(:key) { '2' }
+
+    let(:expected_attributes) do
+      { 'name' => 'from API', 'url' => 'http://localhost:3000/webhooks/1', 'excludeBody' => false, 'filters' => { 'issue-related-events-section' => '' }, 'events' => [], 'enabled' => true, 'self' => 'http://localhost:2990/jira/rest/webhooks/1.0/webhook/2', 'lastUpdatedUser' => 'admin', 'lastUpdatedDisplayName' => 'admin', 'lastUpdated' => 1_453_306_520_188 }
+    end
+
+    let(:expected_collection_length) { 1 }
+
+    it_should_behave_like 'a resource'
+    it_should_behave_like 'a resource with a collection GET endpoint'
+    it_should_behave_like 'a resource with a singular GET endpoint'
+
+    it 'returns a collection of components' do
+      stub_request(:get, site_url + described_class.singular_path(client, key))
+        .to_return(status: 200, body: get_mock_response('webhook/webhook.json'))
+    end
+  end
+end

data/spec/integration/worklog_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe JIRA::Resource::Worklog do
+  with_each_client do |site_url, client|
+    let(:client) { client }
+    let(:site_url) { site_url }
+
+    let(:key) { '10000' }
+
+    let(:target) { JIRA::Resource::Worklog.new(client, attrs: { 'id' => '99999' }, issue_id: '54321') }
+
+    let(:expected_collection_length) { 3 }
+
+    let(:belongs_to) do
+      JIRA::Resource::Issue.new(client, attrs: {
+                                  'id' => '10002', 'fields' => {
+                                    'comment' => { 'comments' => [] }
+                                  }
+                                })
+    end
+
+    let(:expected_attributes) do
+      {
+        'self' => 'http://localhost:2990/jira/rest/api/2/issue/10002/worklog/10000',
+        'id'   => key,
+        'comment' => 'Some epic work.'
+      }
+    end
+
+    let(:attributes_for_post) do
+      { 'timeSpent' => '2d' }
+    end
+    let(:expected_attributes_from_post) do
+      { 'id' => '10001', 'timeSpent' => '2d' }
+    end
+
+    let(:attributes_for_put) do
+      { 'timeSpent' => '2d' }
+    end
+    let(:expected_attributes_from_put) do
+      { 'id' => '10001', 'timeSpent' => '4d' }
+    end
+
+    it_should_behave_like 'a resource'
+    it_should_behave_like 'a resource with a collection GET endpoint'
+    it_should_behave_like 'a resource with a singular GET endpoint'
+    it_should_behave_like 'a resource with a DELETE endpoint'
+    it_should_behave_like 'a resource with a POST endpoint'
+    it_should_behave_like 'a resource with a PUT endpoint'
+  end
+end

data/spec/jira/base_factory_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe JIRA::BaseFactory do
+  class JIRA::Resource::FooFactory < JIRA::BaseFactory; end
+  class JIRA::Resource::Foo; end
+
+  let(:client)  { double }
+  subject       { JIRA::Resource::FooFactory.new(client) }
+
+  it 'initializes correctly' do
+    expect(subject.class).to        eq(JIRA::Resource::FooFactory)
+    expect(subject.client).to       eq(client)
+    expect(subject.target_class).to eq(JIRA::Resource::Foo)
+  end
+
+  it 'proxies all to the target class' do
+    expect(JIRA::Resource::Foo).to receive(:all).with(client)
+    subject.all
+  end
+
+  it 'proxies find to the target class' do
+    expect(JIRA::Resource::Foo).to receive(:find).with(client, 'FOO')
+    subject.find('FOO')
+  end
+
+  it 'returns the target class' do
+    expect(subject.target_class).to eq(JIRA::Resource::Foo)
+  end
+
+  it 'proxies build to the target class' do
+    attrs = double
+    expect(JIRA::Resource::Foo).to receive(:build).with(client, attrs)
+    subject.build(attrs)
+  end
+
+  it 'proxies collection path to the target class' do
+    expect(JIRA::Resource::Foo).to receive(:collection_path).with(client)
+    subject.collection_path
+  end
+
+  it 'proxies singular path to the target class' do
+    expect(JIRA::Resource::Foo).to receive(:singular_path).with(client, 'FOO')
+    subject.singular_path('FOO')
+  end
+end

data/spec/jira/base_spec.rb

@@ -0,0 +1,598 @@
+require 'spec_helper'
+
+describe JIRA::Base do
+  class JIRADelegation < SimpleDelegator # :nodoc:
+  end
+
+  class JIRA::Resource::Deadbeef < JIRA::Base # :nodoc:
+  end
+
+  class JIRA::Resource::HasOneExample < JIRA::Base # :nodoc:
+    has_one :deadbeef
+    has_one :muffin, class: JIRA::Resource::Deadbeef
+    has_one :brunchmuffin, class: JIRA::Resource::Deadbeef,
+                           nested_under: 'nested'
+    has_one :breakfastscone,
+            class: JIRA::Resource::Deadbeef,
+            nested_under: %w[nested breakfastscone]
+    has_one :irregularly_named_thing,
+            class: JIRA::Resource::Deadbeef,
+            attribute_key: 'irregularlyNamedThing'
+  end
+
+  class JIRA::Resource::HasManyExample < JIRA::Base # :nodoc:
+    has_many :deadbeefs
+    has_many :brunchmuffins, class: JIRA::Resource::Deadbeef,
+                             nested_under: 'nested'
+    has_many :breakfastscones,
+             class: JIRA::Resource::Deadbeef,
+             nested_under: %w[nested breakfastscone]
+    has_many :irregularly_named_things,
+             class: JIRA::Resource::Deadbeef,
+             attribute_key: 'irregularlyNamedThings'
+  end
+
+  let(:client)  { double('client') }
+  let(:attrs)   { {} }
+
+  subject { JIRA::Resource::Deadbeef.new(client, attrs: attrs) }
+
+  let(:decorated) { JIRADelegation.new(subject) }
+
+  describe '#respond_to?' do
+    describe 'when decorated using SimpleDelegator' do
+      it 'responds to client' do
+        expect(decorated.respond_to?(:client)).to eq(true)
+      end
+      it 'does not raise an error' do
+        expect do
+          decorated.respond_to?(:client)
+        end.not_to raise_error
+      end
+    end
+  end
+
+  it 'assigns the client and attrs' do
+    expect(subject.client).to eq(client)
+    expect(subject.attrs).to eq(attrs)
+  end
+
+  it 'returns all the deadbeefs' do
+    response = double
+    expect(response).to receive(:body).and_return('[{"self":"http://deadbeef/","id":"98765"}]')
+    expect(client).to receive(:get).with('/jira/rest/api/2/deadbeef').and_return(response)
+    expect(JIRA::Resource::Deadbeef).to receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+    deadbeefs = JIRA::Resource::Deadbeef.all(client)
+    expect(deadbeefs.length).to eq(1)
+    first = deadbeefs.first
+    expect(first.class).to eq(JIRA::Resource::Deadbeef)
+    expect(first.attrs['self']).to eq('http://deadbeef/')
+    expect(first.attrs['id']).to eq('98765')
+    expect(first.expanded?).to be_falsey
+  end
+
+  it 'finds a deadbeef by id' do
+    response = instance_double('Response', body: '{"self":"http://deadbeef/","id":"98765"}')
+    expect(client).to receive(:get).with('/jira/rest/api/2/deadbeef/98765').and_return(response)
+    expect(JIRA::Resource::Deadbeef).to receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+    deadbeef = JIRA::Resource::Deadbeef.find(client, '98765')
+    expect(deadbeef.client).to eq(client)
+    expect(deadbeef.attrs['self']).to eq('http://deadbeef/')
+    expect(deadbeef.attrs['id']).to eq('98765')
+    expect(deadbeef.expanded?).to be_truthy
+  end
+
+  it 'finds a deadbeef containing changelog by id' do
+    response = instance_double(
+      'Response',
+      body: '{"self":"http://deadbeef/","id":"98765","changelog":{"histories":[]}}'
+    )
+    expect(client).to receive(:get).with('/jira/rest/api/2/deadbeef/98765?expand=changelog').and_return(response)
+
+    expect(JIRA::Resource::Deadbeef).to receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+
+    deadbeef = JIRA::Resource::Deadbeef.find(client, '98765', expand: 'changelog')
+    expect(deadbeef.client).to eq(client)
+    expect(deadbeef.attrs['self']).to eq('http://deadbeef/')
+    expect(deadbeef.attrs['id']).to eq('98765')
+    expect(deadbeef.expanded?).to be_truthy
+    expect(deadbeef.attrs['changelog']['histories']).to eq([])
+  end
+
+  it 'builds a deadbeef' do
+    deadbeef = JIRA::Resource::Deadbeef.build(client, 'id' => '98765')
+    expect(deadbeef.expanded?).to be_falsey
+
+    expect(deadbeef.client).to eq(client)
+    expect(deadbeef.attrs['id']).to eq('98765')
+  end
+
+  it 'returns the endpoint name' do
+    expect(subject.class.endpoint_name).to eq('deadbeef')
+  end
+
+  it 'returns the path_component' do
+    attrs['id'] = '123'
+    expect(subject.path_component).to eq('/deadbeef/123')
+  end
+
+  it 'returns the path component for unsaved instances' do
+    expect(subject.path_component).to eq('/deadbeef')
+  end
+
+  it 'converts to a symbol' do
+    expect(subject.to_sym).to eq(:deadbeef)
+  end
+
+  describe 'collection_path' do
+    before(:each) do
+      expect(client).to receive(:options).and_return(rest_base_path: '/deadbeef/bar')
+    end
+
+    it 'returns the collection_path' do
+      expect(subject.collection_path).to eq('/deadbeef/bar/deadbeef')
+    end
+
+    it 'returns the collection_path with a prefix' do
+      expect(subject.collection_path('/baz/')).to eq('/deadbeef/bar/baz/deadbeef')
+    end
+
+    it 'has a class method that returns the collection_path' do
+      expect(subject.class.collection_path(client)).to eq('/deadbeef/bar/deadbeef')
+    end
+  end
+
+  it 'parses json' do
+    expect(described_class.parse_json('{"foo":"bar"}')).to eq('foo' => 'bar')
+  end
+
+  describe 'dynamic instance methods' do
+    let(:attrs) { { 'foo' => 'bar', 'flum' => 'goo', 'object_id' => 'dummy' } }
+    subject     { JIRA::Resource::Deadbeef.new(client, attrs: attrs) }
+
+    it 'responds to each of the top level attribute names' do
+      expect(subject).to respond_to(:foo)
+      expect(subject).to respond_to('flum')
+      expect(subject).to respond_to(:object_id)
+
+      expect(subject.foo).to eq('bar')
+      expect(subject.flum).to eq('goo')
+
+      # Should not override existing method names, but should still allow
+      # access to their values via the attrs[] hash
+      expect(subject.object_id).not_to eq('dummy')
+      expect(subject.attrs['object_id']).to eq('dummy')
+    end
+  end
+
+  describe 'fetch' do
+    subject { JIRA::Resource::Deadbeef.new(client, attrs: { 'id' => '98765' }) }
+
+    describe 'not cached' do
+      before(:each) do
+        response = instance_double('Response', body: '{"self":"http://deadbeef/","id":"98765"}')
+        expect(client).to receive(:get).with('/jira/rest/api/2/deadbeef/98765').and_return(response)
+        expect(JIRA::Resource::Deadbeef).to receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+      end
+
+      it 'sets expanded to true after fetch' do
+        expect(subject.expanded?).to be_falsey
+        subject.fetch
+        expect(subject.expanded?).to be_truthy
+      end
+
+      it 'performs a fetch' do
+        expect(subject.expanded?).to be_falsey
+        subject.fetch
+        expect(subject.self).to eq('http://deadbeef/')
+        expect(subject.id).to eq('98765')
+      end
+
+      it 'performs a fetch if already fetched and force flag is true' do
+        subject.expanded = true
+        subject.fetch(true)
+      end
+    end
+
+    describe 'cached' do
+      it "doesn't perform a fetch if already fetched" do
+        subject.expanded = true
+        expect(client).not_to receive(:get)
+        subject.fetch
+      end
+    end
+
+    context "with expand parameter 'changelog'" do
+      it "fetchs changelogs '" do
+        response = instance_double(
+          'Response',
+          body: '{"self":"http://deadbeef/","id":"98765","changelog":{"histories":[]}}'
+        )
+        expect(client).to receive(:get).with('/jira/rest/api/2/deadbeef/98765?expand=changelog').and_return(response)
+
+        expect(JIRA::Resource::Deadbeef).to receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+
+        subject.fetch(false, expand: 'changelog')
+
+        expect(subject.self).to eq('http://deadbeef/')
+        expect(subject.id).to eq('98765')
+        expect(subject.changelog['histories']).to eq([])
+      end
+    end
+  end
+
+  describe 'save' do
+    let(:response) { double }
+
+    subject { JIRA::Resource::Deadbeef.new(client) }
+
+    before(:each) do
+      expect(subject).to receive(:url).and_return('/foo/bar')
+    end
+
+    it 'POSTs a new record' do
+      response = instance_double('Response', body: '{"id":"123"}')
+      allow(subject).to receive(:new_record?) { true }
+      expect(client).to receive(:post).with('/foo/bar', '{"foo":"bar"}').and_return(response)
+      expect(subject.save('foo' => 'bar')).to be_truthy
+      expect(subject.id).to eq('123')
+      expect(subject.expanded).to be_falsey
+    end
+
+    it 'PUTs an existing record' do
+      response = instance_double('Response', body: nil)
+      allow(subject).to receive(:new_record?) { false }
+      expect(client).to receive(:put).with('/foo/bar', '{"foo":"bar"}').and_return(response)
+      expect(subject.save('foo' => 'bar')).to be_truthy
+      expect(subject.expanded).to be_falsey
+    end
+
+    it 'merges attrs on save' do
+      response = instance_double('Response', body: nil)
+      expect(client).to receive(:post).with('/foo/bar', '{"foo":{"fum":"dum"}}').and_return(response)
+      subject.attrs = { 'foo' => { 'bar' => 'baz' } }
+      subject.save('foo' => { 'fum' => 'dum' })
+      expect(subject.foo).to eq('bar' => 'baz', 'fum' => 'dum')
+    end
+
+    it 'returns false when an invalid field is set' do # The JIRA REST API apparently ignores fields that you aren't allowed to set manually
+      response = instance_double('Response', body: '{"errorMessages":["blah"]}', status: 400)
+      allow(subject).to receive(:new_record?) { false }
+      expect(client).to receive(:put).with('/foo/bar', '{"invalid_field":"foobar"}').and_raise(JIRA::HTTPError.new(response))
+      expect(subject.save('invalid_field' => 'foobar')).to be_falsey
+    end
+
+    it 'returns false with exception details when non json response body (unauthorized)' do # Unauthorized requests return a non-json body. This makes sure we can handle non-json bodies on HTTPError
+      response = double('Response', body: 'totally invalid json', code: 401, message: 'Unauthorized')
+      expect(client).to receive(:post).with('/foo/bar', '{"foo":"bar"}').and_raise(JIRA::HTTPError.new(response))
+      expect(subject.save('foo' => 'bar')).to be_falsey
+      expect(subject.attrs['exception']['code']).to eq(401)
+      expect(subject.attrs['exception']['message']).to eq('Unauthorized')
+    end
+  end
+
+  describe 'save!' do
+    let(:response) { double }
+
+    subject { JIRA::Resource::Deadbeef.new(client) }
+
+    before(:each) do
+      expect(subject).to receive(:url).and_return('/foo/bar')
+    end
+
+    it 'POSTs a new record' do
+      response = instance_double('Response', body: '{"id":"123"}')
+      allow(subject).to receive(:new_record?) { true }
+      expect(client).to receive(:post).with('/foo/bar', '{"foo":"bar"}').and_return(response)
+      expect(subject.save!('foo' => 'bar')).to be_truthy
+      expect(subject.id).to eq('123')
+      expect(subject.expanded).to be_falsey
+    end
+
+    it 'PUTs an existing record' do
+      response = instance_double('Response', body: nil)
+      allow(subject).to receive(:new_record?) { false }
+      expect(client).to receive(:put).with('/foo/bar', '{"foo":"bar"}').and_return(response)
+      expect(subject.save!('foo' => 'bar')).to be_truthy
+      expect(subject.expanded).to be_falsey
+    end
+
+    it 'throws an exception when an invalid field is set' do
+      response = instance_double('Response', body: '{"errorMessages":["blah"]}', status: 400)
+      allow(subject).to receive(:new_record?) { false }
+      expect(client).to receive(:put).with('/foo/bar', '{"invalid_field":"foobar"}').and_raise(JIRA::HTTPError.new(response))
+      expect(-> { subject.save!('invalid_field' => 'foobar') }).to raise_error(JIRA::HTTPError)
+    end
+  end
+
+  describe 'set_attrs' do
+    it 'merges hashes correctly when clobber is true (default)' do
+      subject.attrs = { 'foo' => { 'bar' => 'baz' } }
+      subject.set_attrs('foo' => { 'fum' => 'dum' })
+      expect(subject.foo).to eq('fum' => 'dum')
+    end
+
+    it 'merges hashes correctly when clobber is false' do
+      subject.attrs = { 'foo' => { 'bar' => 'baz' } }
+      subject.set_attrs({ 'foo' => { 'fum' => 'dum' } }, false)
+      expect(subject.foo).to eq('bar' => 'baz', 'fum' => 'dum')
+    end
+  end
+
+  describe 'delete' do
+    before(:each) do
+      expect(client).to receive(:delete).with('/foo/bar')
+      allow(subject).to receive(:url) { '/foo/bar' }
+    end
+
+    it 'flags itself as deleted' do
+      expect(subject.deleted?).to be_falsey
+      subject.delete
+      expect(subject.deleted?).to be_truthy
+    end
+
+    it 'sends a DELETE request' do
+      subject.delete
+    end
+  end
+
+  describe 'new_record?' do
+    it 'returns true for new_record? when new object' do
+      subject.attrs['id'] = nil
+      expect(subject.new_record?).to be_truthy
+    end
+
+    it 'returns false for new_record? when id is set' do
+      subject.attrs['id'] = '123'
+      expect(subject.new_record?).to be_falsey
+    end
+  end
+
+  describe 'has_errors?' do
+    it 'returns true when the response contains errors' do
+      attrs['errors'] = { 'invalid' => 'Field invalid' }
+      expect(subject.has_errors?).to be_truthy
+    end
+
+    it 'returns false when the response does not contain any errors' do
+      expect(subject.has_errors?).to be_falsey
+    end
+  end
+
+  describe 'url' do
+    before(:each) do
+      allow(client).to receive(:options) { { rest_base_path: '/foo/bar' } }
+    end
+
+    it 'returns self as the URL if set' do
+      attrs['self'] = 'http://foo/bar'
+      expect(subject.url).to eq('http://foo/bar')
+    end
+
+    it 'returns path as the URL if set and site options is specified' do
+      allow(client).to receive(:options) { { site: 'http://foo' } }
+      attrs['self'] = 'http://foo/bar'
+      expect(subject.url).to eq('/bar')
+    end
+
+    it 'returns path as the URL if set and site options is specified and ends with a slash' do
+      allow(client).to receive(:options) { { site: 'http://foo/' } }
+      attrs['self'] = 'http://foo/bar'
+      expect(subject.url).to eq('/bar')
+    end
+
+    it 'generates the URL from id if self not set' do
+      attrs['self'] = nil
+      attrs['id'] = '98765'
+      expect(subject.url).to eq('/foo/bar/deadbeef/98765')
+    end
+
+    it 'generates the URL from collection_path if self and id not set' do
+      attrs['self'] = nil
+      attrs['id'] = nil
+      expect(subject.url).to eq('/foo/bar/deadbeef')
+    end
+
+    it 'has a class method for the collection path' do
+      expect(JIRA::Resource::Deadbeef.collection_path(client)).to eq('/foo/bar/deadbeef')
+      # Should accept an optional prefix (flum in this case)
+      expect(JIRA::Resource::Deadbeef.collection_path(client, '/flum/')).to eq('/foo/bar/flum/deadbeef')
+    end
+
+    it 'has a class method for the singular path' do
+      expect(JIRA::Resource::Deadbeef.singular_path(client, 'abc123')).to eq('/foo/bar/deadbeef/abc123')
+      # Should accept an optional prefix (flum in this case)
+      expect(JIRA::Resource::Deadbeef.singular_path(client, 'abc123', '/flum/')).to eq('/foo/bar/flum/deadbeef/abc123')
+    end
+  end
+
+  it 'returns the formatted attrs from to_s' do
+    subject.attrs['foo']  = 'bar'
+    subject.attrs['dead'] = 'beef'
+
+    expect(subject.to_s).to match(/#<JIRA::Resource::Deadbeef:\d+ @attrs=#{Regexp.quote(attrs.inspect)}>/)
+  end
+
+  it 'returns the key attribute' do
+    expect(subject.class.key_attribute).to eq(:id)
+  end
+
+  it 'returns the key value' do
+    subject.attrs['id'] = '123'
+    expect(subject.key_value).to eq('123')
+  end
+
+  it 'converts to json' do
+    subject.attrs = { 'foo' => 'bar', 'dead' => 'beef' }
+    expect(subject.to_json).to eq(subject.attrs.to_json)
+
+    h       = { 'key' => subject }
+    h_attrs = { 'key' => subject.attrs }
+    expect(h.to_json).to eq(h_attrs.to_json)
+  end
+
+  describe 'extract attrs from response' do
+    subject { JIRA::Resource::Deadbeef.new(client, attrs: {}) }
+
+    it 'sets the attrs from a response' do
+      response = instance_double('Response', body: '{"foo":"bar"}')
+
+      expect(subject.set_attrs_from_response(response)).to eq('foo' => 'bar')
+      expect(subject.foo).to eq('bar')
+    end
+
+    it "doesn't clobber existing attrs not in response" do
+      response = instance_double('Response', body: '{"foo":"bar"}')
+
+      subject.attrs = { 'flum' => 'flar' }
+      expect(subject.set_attrs_from_response(response)).to eq('foo' => 'bar')
+      expect(subject.foo).to eq('bar')
+      expect(subject.flum).to eq('flar')
+    end
+
+    it 'handles nil response body' do
+      response = instance_double('Response', body: nil)
+
+      subject.attrs = { 'flum' => 'flar' }
+      expect(subject.set_attrs_from_response(response)).to be_nil
+      expect(subject.flum).to eq('flar')
+    end
+  end
+
+  describe 'nesting' do
+    it 'defaults collection_attributes_are_nested to false' do
+      expect(JIRA::Resource::Deadbeef.collection_attributes_are_nested).to be_falsey
+    end
+
+    it 'allows collection_attributes_are_nested to be set' do
+      JIRA::Resource::Deadbeef.nested_collections true
+      expect(JIRA::Resource::Deadbeef.collection_attributes_are_nested).to be_truthy
+    end
+  end
+
+  describe 'has_many' do
+    subject { JIRA::Resource::HasManyExample.new(client, attrs: { 'deadbeefs' => [{ 'id' => '123' }] }) }
+
+    it 'returns a collection of instances for has_many relationships' do
+      expect(subject.deadbeefs.class).to eq(JIRA::HasManyProxy)
+      expect(subject.deadbeefs.length).to eq(1)
+      subject.deadbeefs.each do |deadbeef|
+        expect(deadbeef.class).to eq(JIRA::Resource::Deadbeef)
+      end
+    end
+
+    it 'returns an empty collection for empty has_many relationships' do
+      subject = JIRA::Resource::HasManyExample.new(client)
+      expect(subject.deadbeefs.length).to eq(0)
+    end
+
+    it 'allows the has_many attributes to be nested inside another attribute' do
+      subject = JIRA::Resource::HasManyExample.new(client, attrs: { 'nested' => { 'brunchmuffins' => [{ 'id' => '123' }, { 'id' => '456' }] } })
+      expect(subject.brunchmuffins.length).to eq(2)
+      subject.brunchmuffins.each do |brunchmuffin|
+        expect(brunchmuffin.class).to eq(JIRA::Resource::Deadbeef)
+      end
+    end
+
+    it 'allows it to be deeply nested' do
+      subject = JIRA::Resource::HasManyExample.new(client, attrs: { 'nested' => {
+                                                     'breakfastscone' => { 'breakfastscones' => [{ 'id' => '123' }, { 'id' => '456' }] }
+                                                   } })
+      expect(subject.breakfastscones.length).to eq(2)
+      subject.breakfastscones.each do |breakfastscone|
+        expect(breakfastscone.class).to eq(JIRA::Resource::Deadbeef)
+      end
+    end
+
+    it 'short circuits missing deeply nested attrs' do
+      subject = JIRA::Resource::HasManyExample.new(client, attrs: {
+                                                     'nested' => {}
+                                                   })
+      expect(subject.breakfastscones.length).to eq(0)
+    end
+
+    it 'allows the attribute key to be specified' do
+      subject = JIRA::Resource::HasManyExample.new(client, attrs: { 'irregularlyNamedThings' => [{ 'id' => '123' }, { 'id' => '456' }] })
+      expect(subject.irregularly_named_things.length).to eq(2)
+      subject.irregularly_named_things.each do |thing|
+        expect(thing.class).to eq(JIRA::Resource::Deadbeef)
+      end
+    end
+
+    it 'can build child instances' do
+      deadbeef = subject.deadbeefs.build
+      expect(deadbeef.class).to eq(JIRA::Resource::Deadbeef)
+    end
+  end
+
+  describe 'has_one' do
+    subject { JIRA::Resource::HasOneExample.new(client, attrs: { 'deadbeef' => { 'id' => '123' } }) }
+
+    it 'returns an instance for a has one relationship' do
+      expect(subject.deadbeef.class).to eq(JIRA::Resource::Deadbeef)
+      expect(subject.deadbeef.id).to eq('123')
+    end
+
+    it 'returns nil when resource attribute is nonexistent' do
+      subject = JIRA::Resource::HasOneExample.new(client)
+      expect(subject.deadbeef).to be_nil
+    end
+
+    it 'returns an instance with a different class name to the attribute name' do
+      subject = JIRA::Resource::HasOneExample.new(client, attrs: { 'muffin' => { 'id' => '123' } })
+      expect(subject.muffin.class).to eq(JIRA::Resource::Deadbeef)
+      expect(subject.muffin.id).to eq('123')
+    end
+
+    it 'allows the has_one attributes to be nested inside another attribute' do
+      subject = JIRA::Resource::HasOneExample.new(client, attrs: { 'nested' => { 'brunchmuffin' => { 'id' => '123' } } })
+      expect(subject.brunchmuffin.class).to eq(JIRA::Resource::Deadbeef)
+      expect(subject.brunchmuffin.id).to eq('123')
+    end
+
+    it 'allows it to be deeply nested' do
+      subject = JIRA::Resource::HasOneExample.new(client, attrs: { 'nested' => {
+                                                    'breakfastscone' => { 'breakfastscone' => { 'id' => '123' } }
+                                                  } })
+      expect(subject.breakfastscone.class).to eq(JIRA::Resource::Deadbeef)
+      expect(subject.breakfastscone.id).to eq('123')
+    end
+
+    it 'allows the attribute key to be specified' do
+      subject = JIRA::Resource::HasOneExample.new(client, attrs: { 'irregularlyNamedThing' => { 'id' => '123' } })
+      expect(subject.irregularly_named_thing.class).to eq(JIRA::Resource::Deadbeef)
+      expect(subject.irregularly_named_thing.id).to eq('123')
+    end
+  end
+
+  describe 'belongs_to' do
+    class JIRA::Resource::BelongsToExample < JIRA::Base
+      belongs_to :deadbeef
+    end
+
+    let(:deadbeef) { JIRA::Resource::Deadbeef.new(client, attrs: { 'id' => '999' }) }
+
+    subject { JIRA::Resource::BelongsToExample.new(client, attrs: { 'id' => '123' }, deadbeef: deadbeef) }
+
+    it 'sets up an accessor for the belongs to relationship' do
+      expect(subject.deadbeef).to eq(deadbeef)
+    end
+
+    it 'raises an exception when initialized without a belongs_to instance' do
+      expect(lambda {
+        JIRA::Resource::BelongsToExample.new(client, attrs: { 'id' => '123' })
+      }).to raise_exception(ArgumentError, 'Required option :deadbeef missing')
+    end
+
+    it 'returns the right url' do
+      allow(client).to receive(:options) { { rest_base_path: '/foo' } }
+      expect(subject.url).to eq('/foo/deadbeef/999/belongstoexample/123')
+    end
+
+    it 'can be initialized with an instance or a key value' do
+      allow(client).to receive(:options) { { rest_base_path: '/foo' } }
+      subject = JIRA::Resource::BelongsToExample.new(client, attrs: { 'id' => '123' }, deadbeef_id: '987')
+      expect(subject.url).to eq('/foo/deadbeef/987/belongstoexample/123')
+    end
+  end
+end