jira-ruby 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc4f6eb059f491b8aeaf07b2ee453aa9eee6687b
-  data.tar.gz: 29f02ed0e3c66b1a06d71342cf7e04574d282c94
+  metadata.gz: fd0485d4d1924b9830318cc9875ff1d5284f605a
+  data.tar.gz: b211fbe17e3ffa4033a93ab043abeeb93db0d5df
 SHA512:
-  metadata.gz: 0f176491a5f2ff1558d883f0ac6e5d5b92b2f9aac29a2b6183720e09bfd3ec8a7ae96a12e257f4c92e9f293ddbfc2828287c019dc38a45fb194ac0bcd01d2937
-  data.tar.gz: e3b7707569609d99b6431bc20c9f8def378f15286b161e40d51941b9199343ef930a0ad10bee27c80f24dc7b3596f9da5d3ff752c143d1e13f4fdbc02a628406
+  metadata.gz: d26f6b648a24d94301771c970c224acce705508354f58eee97884ddd92fcac60a1779c332a248a8b4ad9bd03af6ebb4ae10e4a37416f44f49ddab534416566fa
+  data.tar.gz: 16293a18535b195e2df37a86b25195de1e39cd68ab350e3f872753e3537fd8090548058aa6d3ec52dcfdf8ac5c36326fcc6a3036e79edd49545c303d06c66f9b

data/jira-ruby.gemspec

@@ -18,11 +18,11 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "railties"
-  s.add_runtime_dependency "oauth"
-  s.add_runtime_dependency "activesupport"
-  s.add_development_dependency "webmock"
-  s.add_development_dependency "rspec"
-  s.add_development_dependency "rake"
+  s.add_development_dependency "railties", '~> 4.1.4'
+  s.add_runtime_dependency "oauth", '~> 0.4.7'
+  s.add_runtime_dependency "activesupport", '~> 4.1.4'
+  s.add_development_dependency "webmock", '~> 1.18.0'
+  s.add_development_dependency "rspec", '~> 3.0.0'
+  s.add_development_dependency "rake", '~> 10.3.2'
 end
 

data/lib/jira/version.rb

@@ -1,3 +1,3 @@
 module JIRA
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

data/spec/integration/issue_spec.rb

@@ -69,7 +69,7 @@ describe JIRA::Resource::Issue do
       it "fails to save when fields and update are missing" do
         subject = client.Issue.build('id' => '10002')
         subject.fetch
-        subject.save('missing' => 'fields and update').should be_false
+        expect(subject.save('missing' => 'fields and update')).to be_falsey
       end
 
     end

data/spec/integration/project_spec.rb

@@ -30,10 +30,10 @@ describe JIRA::Resource::Project do
           to_return(:status => 200, :body => get_mock_response('project/SAMPLEPROJECT.issues.json'))
         subject = client.Project.build('key' => key)
         issues = subject.issues
-        issues.length.should == 11
+        expect(issues.length).to eq(11)
         issues.each do |issue|
-          issue.class.should == JIRA::Resource::Issue
-          issue.expanded?.should be_false
+          expect(issue.class).to eq(JIRA::Resource::Issue)
+          expect(issue.expanded?).to be_falsey
         end
 
       end
@@ -46,9 +46,9 @@ describe JIRA::Resource::Project do
         to_return(:status => 200, :body => get_mock_response('project/SAMPLEPROJECT.json'))
 
       subject = client.Project.find(key)
-      subject.components.length.should == 2
+      expect(subject.components.length).to eq(2)
       subject.components.each do |component|
-        component.class.should == JIRA::Resource::Component
+        expect(component.class).to eq(JIRA::Resource::Component)
       end
 
     end

data/spec/integration/transition_spec.rb

@@ -43,7 +43,7 @@ describe JIRA::Resource::Transition do
           .with(:body => attributes_for_post.to_json)
           .to_return(:status => 200, :body => get_mock_from_path(:post))
         subject = build_receiver.build
-        subject.save(attributes_for_post).should be_true
+        expect(subject.save(attributes_for_post)).to be_truthy
       end
     end
 

data/spec/jira/base_factory_spec.rb

@@ -9,38 +9,38 @@ describe JIRA::BaseFactory do
   subject       { JIRA::Resource::FooFactory.new(client) }
 
   it "initializes correctly" do
-    subject.class.should        == JIRA::Resource::FooFactory
-    subject.client.should       == client
-    subject.target_class.should == JIRA::Resource::Foo
+    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
-    JIRA::Resource::Foo.should_receive(:all).with(client)
+    expect(JIRA::Resource::Foo).to receive(:all).with(client)
     subject.all
   end
 
   it "proxies find to the target class" do
-    JIRA::Resource::Foo.should_receive(:find).with(client, 'FOO')
+    expect(JIRA::Resource::Foo).to receive(:find).with(client, 'FOO')
     subject.find('FOO')
   end
 
   it "returns the target class" do
-    subject.target_class.should == JIRA::Resource::Foo
+    expect(subject.target_class).to eq(JIRA::Resource::Foo)
   end
 
   it "proxies build to the target class" do
     attrs = double()
-    JIRA::Resource::Foo.should_receive(:build).with(client, attrs)
+    expect(JIRA::Resource::Foo).to receive(:build).with(client, attrs)
     subject.build(attrs)
   end
 
   it "proxies collection path to the target class" do
-    JIRA::Resource::Foo.should_receive(:collection_path).with(client)
+    expect(JIRA::Resource::Foo).to receive(:collection_path).with(client)
     subject.collection_path
   end
 
   it "proxies singular path to the target class" do
-    JIRA::Resource::Foo.should_receive(:singular_path).with(client, 'FOO')
+    expect(JIRA::Resource::Foo).to receive(:singular_path).with(client, 'FOO')
     subject.singular_path('FOO')
   end
 end

data/spec/jira/base_spec.rb

@@ -37,97 +37,98 @@ describe JIRA::Base do
   subject { JIRA::Resource::Deadbeef.new(client, :attrs => attrs) }
 
   it "assigns the client and attrs" do
-    subject.client.should == client
-    subject.attrs.should  == attrs
+    expect(subject.client).to eq(client)
+    expect(subject.attrs).to eq(attrs)
   end
 
   it "returns all the deadbeefs" do
     response = double()
-    response.should_receive(:body).and_return('[{"self":"http://deadbeef/","id":"98765"}]')
-    client.should_receive(:get).with('/jira/rest/api/2/deadbeef').and_return(response)
-    JIRA::Resource::Deadbeef.should_receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+    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)
-    deadbeefs.length.should == 1
+    expect(deadbeefs.length).to eq(1)
     first = deadbeefs.first
-    first.class.should == JIRA::Resource::Deadbeef
-    first.attrs['self'].should  == 'http://deadbeef/'
-    first.attrs['id'].should   == '98765'
-    first.expanded?.should be_false
+    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 = double()
-    response.stub(:body).and_return('{"self":"http://deadbeef/","id":"98765"}')
-    client.should_receive(:get).with('/jira/rest/api/2/deadbeef/98765').and_return(response)
-    JIRA::Resource::Deadbeef.should_receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+    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')
-    deadbeef.client.should == client
-    deadbeef.attrs['self'].should  == 'http://deadbeef/'
-    deadbeef.attrs['id'].should   == '98765'
-    deadbeef.expanded?.should be_true
+    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 = double() 
-    response.stub(:body).and_return('{"self":"http://deadbeef/","id":"98765","changelog":{"histories":[]}}')
-    client.should_receive(:get).with('/jira/rest/api/2/deadbeef/98765?expand=changelog').and_return(response)
+    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)
 
-    JIRA::Resource::Deadbeef.should_receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+    expect(JIRA::Resource::Deadbeef).to receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
 
     deadbeef = JIRA::Resource::Deadbeef.find(client, '98765', {expand:'changelog'})
-    deadbeef.client.should == client
-    deadbeef.attrs['self'].should  == 'http://deadbeef/'
-    deadbeef.attrs['id'].should   == '98765'
-    deadbeef.expanded?.should be_true
-    deadbeef.attrs['changelog']['histories'].should == []
+    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" )
-    deadbeef.expanded?.should be_false
+    expect(deadbeef.expanded?).to be_falsey
 
-    deadbeef.client.should == client
-    deadbeef.attrs['id'].should   == '98765'
+    expect(deadbeef.client).to eq(client)
+    expect(deadbeef.attrs['id']).to eq('98765')
   end
 
   it "returns the endpoint name" do
-    subject.class.endpoint_name.should == 'deadbeef'
+    expect(subject.class.endpoint_name).to eq('deadbeef')
   end
 
   it "returns the path_component" do
     attrs['id'] = '123'
-    subject.path_component.should == '/deadbeef/123'
+    expect(subject.path_component).to eq('/deadbeef/123')
   end
 
   it "returns the path component for unsaved instances" do
-    subject.path_component.should == '/deadbeef'
+    expect(subject.path_component).to eq('/deadbeef')
   end
 
   it "converts to a symbol" do
-    subject.to_sym.should == :deadbeef
+    expect(subject.to_sym).to eq(:deadbeef)
   end
 
   describe "collection_path" do
 
     before(:each) do
-      client.should_receive(:options).and_return(:rest_base_path => '/deadbeef/bar')
+      expect(client).to receive(:options).and_return(:rest_base_path => '/deadbeef/bar')
     end
 
     it "returns the collection_path" do
-      subject.collection_path.should == '/deadbeef/bar/deadbeef'
+      expect(subject.collection_path).to eq('/deadbeef/bar/deadbeef')
     end
 
     it "returns the collection_path with a prefix" do
-      subject.collection_path('/baz/').should == '/deadbeef/bar/baz/deadbeef'
+      expect(subject.collection_path('/baz/')).to eq('/deadbeef/bar/baz/deadbeef')
     end
 
     it "has a class method that returns the collection_path" do
-      subject.class.collection_path(client).should == '/deadbeef/bar/deadbeef'
+      expect(subject.class.collection_path(client)).to eq('/deadbeef/bar/deadbeef')
     end
   end
 
   it "parses json" do
-    described_class.parse_json('{"foo":"bar"}').should == {"foo" => "bar"}
+    expect(described_class.parse_json('{"foo":"bar"}')).to eq({"foo" => "bar"})
   end
 
   describe "dynamic instance methods" do
@@ -136,17 +137,17 @@ describe JIRA::Base do
     subject     { JIRA::Resource::Deadbeef.new(client, :attrs => attrs) }
 
     it "responds to each of the top level attribute names" do
-      subject.should respond_to(:foo)
-      subject.should respond_to('flum')
-      subject.should respond_to(:object_id)
+      expect(subject).to respond_to(:foo)
+      expect(subject).to respond_to('flum')
+      expect(subject).to respond_to(:object_id)
 
-      subject.foo.should  == 'bar'
-      subject.flum.should == 'goo'
+      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
-      subject.object_id.should_not == 'dummy'
-      subject.attrs['object_id'].should == 'dummy'
+      expect(subject.object_id).not_to eq('dummy')
+      expect(subject.attrs['object_id']).to eq('dummy')
     end
   end
 
@@ -157,23 +158,22 @@ describe JIRA::Base do
     describe "not cached" do
 
       before(:each) do
-        response = double()
-        response.stub(:body).and_return('{"self":"http://deadbeef/","id":"98765"}')
-        client.should_receive(:get).with('/jira/rest/api/2/deadbeef/98765').and_return(response)
-        JIRA::Resource::Deadbeef.should_receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+        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
-        subject.expanded?.should be_false
+        expect(subject.expanded?).to be_falsey
         subject.fetch
-        subject.expanded?.should be_true
+        expect(subject.expanded?).to be_truthy
       end
 
       it "performs a fetch" do
-        subject.expanded?.should be_false
+        expect(subject.expanded?).to be_falsey
         subject.fetch
-        subject.self.should == "http://deadbeef/"
-        subject.id.should  == "98765"
+        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
@@ -186,24 +186,26 @@ describe JIRA::Base do
     describe "cached" do
       it "doesn't perform a fetch if already fetched" do
         subject.expanded = true
-        client.should_not_receive(:get)
+        expect(client).not_to receive(:get)
         subject.fetch
       end
     end
 
     context "with expand parameter 'changelog'" do
       it "fetchs changelogs '" do
-        response = double() 
-        response.stub(:body).and_return('{"self":"http://deadbeef/","id":"98765","changelog":{"histories":[]}}')
-        client.should_receive(:get).with('/jira/rest/api/2/deadbeef/98765?expand=changelog').and_return(response)
+        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)
 
-        JIRA::Resource::Deadbeef.should_receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
+        expect(JIRA::Resource::Deadbeef).to receive(:collection_path).and_return('/jira/rest/api/2/deadbeef')
 
         subject.fetch(false, {expand:'changelog'})
 
-        subject.self.should == "http://deadbeef/"
-        subject.id.should  == "98765"
-        subject.changelog['histories'].should == []
+        expect(subject.self).to eq("http://deadbeef/")
+        expect(subject.id).to eq("98765")
+        expect(subject.changelog['histories']).to eq([])
       end
     end
   end
@@ -215,39 +217,39 @@ describe JIRA::Base do
     subject { JIRA::Resource::Deadbeef.new(client) }
 
     before(:each) do
-      subject.should_receive(:url).and_return('/foo/bar')
+      expect(subject).to receive(:url).and_return('/foo/bar')
     end
 
     it "POSTs a new record" do
-      response.stub(:body => '{"id":"123"}')
-      subject.stub(:new_record? => true)
-      client.should_receive(:post).with('/foo/bar','{"foo":"bar"}').and_return(response)
-      subject.save("foo" => "bar").should be_true
-      subject.id.should == "123"
-      subject.expanded.should be_false
+      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.stub(:body => nil)
-      subject.stub(:new_record? => false)
-      client.should_receive(:put).with('/foo/bar','{"foo":"bar"}').and_return(response)
-      subject.save("foo" => "bar").should be_true
-      subject.expanded.should be_false
+      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.stub(:body => nil)
-      client.should_receive(:post).with('/foo/bar','{"foo":{"fum":"dum"}}').and_return(response)
+      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"}})
-      subject.foo.should == {"bar" => "baz", "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.stub(:body => '{"errorMessages":["blah"]}', :status => 400)
-      subject.stub(:new_record? => false)
-      client.should_receive(:put).with('/foo/bar','{"invalid_field":"foobar"}').and_raise(JIRA::HTTPError.new(response))
-      subject.save("invalid_field" => "foobar").should be_false
+      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
 
   end
@@ -258,33 +260,31 @@ describe JIRA::Base do
     subject { JIRA::Resource::Deadbeef.new(client) }
 
     before(:each) do
-      subject.should_receive(:url).and_return('/foo/bar')
+      expect(subject).to receive(:url).and_return('/foo/bar')
     end
 
     it "POSTs a new record" do
-      response.stub(:body => '{"id":"123"}')
-      subject.stub(:new_record? => true)
-      client.should_receive(:post).with('/foo/bar','{"foo":"bar"}').and_return(response)
-      subject.save!("foo" => "bar").should be_true
-      subject.id.should == "123"
-      subject.expanded.should be_false
+      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.stub(:body => nil)
-      subject.stub(:new_record? => false)
-      client.should_receive(:put).with('/foo/bar','{"foo":"bar"}').and_return(response)
-      subject.save!("foo" => "bar").should be_true
-      subject.expanded.should be_false
+      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.stub(:body => '{"errorMessages":["blah"]}', :status => 400)
-      subject.stub(:new_record? => false)
-      client.should_receive(:put).with('/foo/bar','{"invalid_field":"foobar"}').and_raise(JIRA::HTTPError.new(response))
-      lambda do
-        subject.save!("invalid_field" => "foobar")
-      end.should raise_error(JIRA::HTTPError)
+      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(lambda{ subject.save!("invalid_field" => "foobar") }).to raise_error(JIRA::HTTPError)
     end
   end
 
@@ -292,27 +292,27 @@ describe JIRA::Base do
     it "merges hashes correctly when clobber is true (default)" do
       subject.attrs = {"foo" => {"bar" => "baz"}}
       subject.set_attrs({"foo" => {"fum" => "dum"}})
-      subject.foo.should == {"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)
-      subject.foo.should == {"bar" => "baz", "fum" => "dum"}
+      expect(subject.foo).to eq({"bar" => "baz", "fum" => "dum"})
     end
   end
 
   describe "delete" do
 
     before(:each) do
-      client.should_receive(:delete).with('/foo/bar')
-      subject.stub(:url => '/foo/bar')
+      expect(client).to receive(:delete).with('/foo/bar')
+      allow(subject).to receive(:url) { '/foo/bar' }
     end
 
     it "flags itself as deleted" do
-      subject.deleted?.should be_false
+      expect(subject.deleted?).to be_falsey
       subject.delete
-      subject.deleted?.should be_true
+      expect(subject.deleted?).to be_truthy
     end
 
     it "sends a DELETE request" do
@@ -325,12 +325,12 @@ describe JIRA::Base do
 
     it "returns true for new_record? when new object" do
       subject.attrs['id'] = nil
-      subject.new_record?.should be_true
+      expect(subject.new_record?).to be_truthy
     end
 
     it "returns false for new_record? when id is set" do
       subject.attrs['id'] = '123'
-      subject.new_record?.should be_false
+      expect(subject.new_record?).to be_falsey
     end
 
   end
@@ -339,11 +339,11 @@ describe JIRA::Base do
 
     it "returns true when the response contains errors" do
       attrs["errors"] = {"invalid" => "Field invalid"}
-      subject.has_errors?.should be_true
+      expect(subject.has_errors?).to be_truthy
     end
 
     it "returns false when the response does not contain any errors" do
-      subject.has_errors?.should be_false
+      expect(subject.has_errors?).to be_falsey
     end
 
   end
@@ -351,37 +351,37 @@ describe JIRA::Base do
   describe 'url' do
 
     before(:each) do
-      client.stub(:options => {:rest_base_path => '/foo/bar'})
+      allow(client).to receive(:options) { {:rest_base_path => '/foo/bar'} }
     end
 
     it "returns self as the URL if set" do
       pending("Identified bug on real jira instance")
       attrs['self'] = 'http://foo/bar'
-      subject.url.should == "http://foo/bar"
+      expect(subject.url).to eq("http://foo/bar")
     end
 
     it "generates the URL from id if self not set" do
       attrs['self'] = nil
       attrs['id'] = '98765'
-      subject.url.should == "/foo/bar/deadbeef/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
-      subject.url.should == "/foo/bar/deadbeef"
+      expect(subject.url).to eq("/foo/bar/deadbeef")
     end
 
     it "has a class method for the collection path" do
-      JIRA::Resource::Deadbeef.collection_path(client).should == "/foo/bar/deadbeef"
+      expect(JIRA::Resource::Deadbeef.collection_path(client)).to eq("/foo/bar/deadbeef")
       #Should accept an optional prefix (flum in this case)
-      JIRA::Resource::Deadbeef.collection_path(client, '/flum/').should == "/foo/bar/flum/deadbeef"
+      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
-      JIRA::Resource::Deadbeef.singular_path(client, 'abc123').should == "/foo/bar/deadbeef/abc123"
+      expect(JIRA::Resource::Deadbeef.singular_path(client, 'abc123')).to eq("/foo/bar/deadbeef/abc123")
       #Should accept an optional prefix (flum in this case)
-      JIRA::Resource::Deadbeef.singular_path(client, 'abc123', '/flum/').should == "/foo/bar/flum/deadbeef/abc123"
+      expect(JIRA::Resource::Deadbeef.singular_path(client, 'abc123', '/flum/')).to eq("/foo/bar/flum/deadbeef/abc123")
     end
   end
 
@@ -389,22 +389,22 @@ describe JIRA::Base do
     subject.attrs['foo']  = 'bar'
     subject.attrs['dead'] = 'beef'
 
-    subject.to_s.should match(/#<JIRA::Resource::Deadbeef:\d+ @attrs=#{Regexp.quote(attrs.inspect)}>/)
+    expect(subject.to_s).to match(/#<JIRA::Resource::Deadbeef:\d+ @attrs=#{Regexp.quote(attrs.inspect)}>/)
   end
 
   it "returns the key attribute" do
-    subject.class.key_attribute.should == :id
+    expect(subject.class.key_attribute).to eq(:id)
   end
 
   it "returns the key value" do
     subject.attrs['id'] = '123'
-    subject.key_value.should == '123'
+    expect(subject.key_value).to eq('123')
   end
 
   it "converts to json" do
     subject.attrs = {"foo" => "bar","dead" => "beef"}
 
-    subject.to_json.should == subject.attrs.to_json
+    expect(subject.to_json).to eq(subject.attrs.to_json)
   end
 
   describe "extract attrs from response" do
@@ -412,42 +412,39 @@ describe JIRA::Base do
     subject { JIRA::Resource::Deadbeef.new(client, :attrs => {}) }
 
     it "sets the attrs from a response" do
-      response = double()
-      response.stub(:body).and_return('{"foo":"bar"}')
+      response = instance_double("Response", body: '{"foo":"bar"}')
 
-      subject.set_attrs_from_response(response).should == {'foo' => 'bar'}
-      subject.foo.should == "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 = double()
-      response.stub(:body).and_return('{"foo":"bar"}')
+      response = instance_double("Response", body: '{"foo":"bar"}')
 
       subject.attrs = {'flum' => 'flar'}
-      subject.set_attrs_from_response(response).should == {'foo' => 'bar'}
-      subject.foo.should == "bar"
-      subject.flum.should == "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 = double()
-      response.stub(:body).and_return(nil)
+      response = instance_double("Response", body: nil)
 
       subject.attrs = {'flum' => 'flar'}
-      subject.set_attrs_from_response(response).should be_nil
-      subject.flum.should == '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
-      JIRA::Resource::Deadbeef.collection_attributes_are_nested.should be_false
+      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
-      JIRA::Resource::Deadbeef.collection_attributes_are_nested.should be_true
+      expect(JIRA::Resource::Deadbeef.collection_attributes_are_nested).to be_truthy
     end
 
   end
@@ -457,23 +454,23 @@ describe JIRA::Base do
     subject { JIRA::Resource::HasManyExample.new(client, :attrs => {'deadbeefs' => [{'id' => '123'}]}) }
 
     it "returns a collection of instances for has_many relationships" do
-      subject.deadbeefs.class.should == JIRA::HasManyProxy
-      subject.deadbeefs.length.should == 1
+      expect(subject.deadbeefs.class).to eq(JIRA::HasManyProxy)
+      expect(subject.deadbeefs.length).to eq(1)
       subject.deadbeefs.each do |deadbeef|
-        deadbeef.class.should == JIRA::Resource::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)
-      subject.deadbeefs.length.should == 0
+      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'}]}})
-      subject.brunchmuffins.length.should == 2
+      expect(subject.brunchmuffins.length).to eq(2)
       subject.brunchmuffins.each do |brunchmuffin|
-        brunchmuffin.class.should == JIRA::Resource::Deadbeef
+        expect(brunchmuffin.class).to eq(JIRA::Resource::Deadbeef)
       end
     end
 
@@ -481,9 +478,9 @@ describe JIRA::Base do
       subject = JIRA::Resource::HasManyExample.new(client, :attrs => {'nested' => {
         'breakfastscone' => { 'breakfastscones' => [{'id' => '123'},{'id' => '456'}] }
       }})
-      subject.breakfastscones.length.should == 2
+      expect(subject.breakfastscones.length).to eq(2)
       subject.breakfastscones.each do |breakfastscone|
-        breakfastscone.class.should == JIRA::Resource::Deadbeef
+        expect(breakfastscone.class).to eq(JIRA::Resource::Deadbeef)
       end
     end
 
@@ -491,20 +488,20 @@ describe JIRA::Base do
       subject = JIRA::Resource::HasManyExample.new(client, :attrs => {
                                                   'nested' => {}
       })
-      subject.breakfastscones.length.should == 0
+      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'}]})
-      subject.irregularly_named_things.length.should == 2
+      expect(subject.irregularly_named_things.length).to eq(2)
       subject.irregularly_named_things.each do |thing|
-        thing.class.should == JIRA::Resource::Deadbeef
+        expect(thing.class).to eq(JIRA::Resource::Deadbeef)
       end
     end
 
     it "can build child instances" do
       deadbeef = subject.deadbeefs.build
-      deadbeef.class.should == JIRA::Resource::Deadbeef
+      expect(deadbeef.class).to eq(JIRA::Resource::Deadbeef)
     end
 
   end
@@ -514,39 +511,39 @@ describe JIRA::Base do
     subject { JIRA::Resource::HasOneExample.new(client, :attrs => {'deadbeef' => {'id' => '123'}}) }
 
     it "returns an instance for a has one relationship" do
-      subject.deadbeef.class.should == JIRA::Resource::Deadbeef
-      subject.deadbeef.id.should == '123'
+      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)
-      subject.deadbeef.should be_nil
+      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'}})
-      subject.muffin.class.should == JIRA::Resource::Deadbeef
-      subject.muffin.id.should == '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'}}})
-      subject.brunchmuffin.class.should == JIRA::Resource::Deadbeef
-      subject.brunchmuffin.id.should == '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'} }
       }})
-      subject.breakfastscone.class.should == JIRA::Resource::Deadbeef
-      subject.breakfastscone.id.should == '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'}})
-      subject.irregularly_named_thing.class.should == JIRA::Resource::Deadbeef
-      subject.irregularly_named_thing.id.should == '123'
+      expect(subject.irregularly_named_thing.class).to eq(JIRA::Resource::Deadbeef)
+      expect(subject.irregularly_named_thing.id).to eq('123')
     end
 
   end
@@ -562,24 +559,24 @@ describe JIRA::Base do
     subject { JIRA::Resource::BelongsToExample.new(client, :attrs => {'id' => '123'}, :deadbeef => deadbeef) }
 
     it "sets up an accessor for the belongs to relationship" do
-      subject.deadbeef.should == deadbeef
+      expect(subject.deadbeef).to eq(deadbeef)
     end
 
     it "raises an exception when initialized without a belongs_to instance" do
-      lambda do
+      expect(lambda {
         JIRA::Resource::BelongsToExample.new(client, :attrs => {'id' => '123'})
-      end.should raise_exception(ArgumentError,"Required option :deadbeef missing")
+      }).to raise_exception(ArgumentError,"Required option :deadbeef missing")
     end
 
     it "returns the right url" do
-      client.stub(:options => { :rest_base_path => "/foo" })
-      subject.url.should == "/foo/deadbeef/999/belongstoexample/123"
+      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
-      client.stub(:options => { :rest_base_path => "/foo" })
+      allow(client).to receive(:options) { { :rest_base_path => "/foo" } }
       subject = JIRA::Resource::BelongsToExample.new(client, :attrs => {'id' => '123'}, :deadbeef_id => '987')
-      subject.url.should == "/foo/deadbeef/987/belongstoexample/123"
+      expect(subject.url).to eq("/foo/deadbeef/987/belongstoexample/123")
     end
 
   end