chore: update RSpec to 3.13

wpramio · wpramio · commit 147739069891 · 2025-09-04T19:36:11.000-03:00
and update specs syntax (mocks and be_true/be_false)
diff --git a/Gemfile b/Gemfile
@@ -3,7 +3,7 @@ source 'http://rubygems.org'
 gemspec
 
 group :development, :test do
-  gem 'rspec', '~> 2.10'
+  gem 'rspec'
   gem 'forgery'
   gem 'rake'
 end
diff --git a/Gemfile.lock b/Gemfile.lock
@@ -9,18 +9,23 @@ GEM
   remote: http://rubygems.org/
   specs:
     base64 (0.3.0)
-    diff-lcs (1.1.3)
+    diff-lcs (1.6.2)
     forgery (0.5.0)
     rake (12.3.3)
     rexml (3.2.5)
-    rspec (2.10.0)
-      rspec-core (~> 2.10.0)
-      rspec-expectations (~> 2.10.0)
-      rspec-mocks (~> 2.10.0)
-    rspec-core (2.10.0)
-    rspec-expectations (2.10.0)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.10.0)
+    rspec (3.13.1)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.5)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.5)
     xml-simple (1.1.9)
       rexml
 
@@ -31,7 +36,7 @@ DEPENDENCIES
   bigbluebutton-api-ruby!
   forgery
   rake
-  rspec (~> 2.10)
+  rspec
 
 BUNDLED WITH
    2.6.9
diff --git a/features/step_definitions/check_status_steps.rb b/features/step_definitions/check_status_steps.rb
@@ -1,11 +1,11 @@
 When /^the method isMeetingRunning informs that the meeting is running$/ do
   @req.response = @api.is_meeting_running?(@req.id)
-  @req.response.should be_true
+  @req.response.should be true
 end
 
 When /^the method isMeetingRunning informs that the meeting is not running$/i do
   @req.response = @api.is_meeting_running?(@req.id)
-  @req.response.should be_false
+  @req.response.should be false
 end
 
 When /^calling the method get_meetings$/ do
@@ -29,8 +29,8 @@
   found[:attendeePW].should be_a(String)
   found[:attendeePW].should_not be_empty
   found[:moderatorPW].should == @req.mod_pass
-  found[:hasBeenForciblyEnded].should be_false
-  found[:running].should be_false
+  found[:hasBeenForciblyEnded].should be false
+  found[:running].should be false
   if @api.version >= "0.8"
     found[:meetingName].should == @req.id
     found[:createTime].should be_a(Numeric)
@@ -40,8 +40,8 @@
 When /^it shows all the information of the meeting that was created$/ do
   @req.response = @api.get_meeting_info(@req.id, @req.mod_pass)
   @req.response[:meetingID].should == @req.id
-  @req.response[:running].should be_false
-  @req.response[:hasBeenForciblyEnded].should be_false
+  @req.response[:running].should be false
+  @req.response[:hasBeenForciblyEnded].should be false
   @req.response[:startTime].should be_nil
   @req.response[:endTime].should be_nil
   @req.response[:participantCount].should == 0
@@ -70,7 +70,7 @@
 
     @req.opts.has_key?(:record) ?
       (@req.response[:recording].should == @req.opts[:record]) :
-      (@req.response[:recording].should be_false)
+      (@req.response[:recording].should be false)
     @req.opts.has_key?(:maxParticipants) ?
       (@req.response[:maxUsers].should == @req.opts[:maxParticipants]) :
       (@req.response[:maxUsers].should == 20)
@@ -98,9 +98,9 @@
   @req.response = @api.get_meeting_info(@req.id, @req.mod_pass)
   participants = count.to_i
 
-  @req.response[:running].should be_true
+  @req.response[:running].should be true
   @req.response[:moderatorCount].should > 0
-  @req.response[:hasBeenForciblyEnded].should be_false
+  @req.response[:hasBeenForciblyEnded].should be false
   @req.response[:participantCount].should == participants
   @req.response[:attendees].size.should == 2
 
diff --git a/features/step_definitions/common_steps.rb b/features/step_definitions/common_steps.rb
@@ -57,11 +57,11 @@
 end
 
 When /^the response is successful$/ do
-  @req.response[:returncode].should be_true
+  @req.response[:returncode].should be true
 end
 
 When /^the response is successful with no messages$/ do
-  @req.response[:returncode].should be_true
+  @req.response[:returncode].should be true
   @req.response[:messageKey].should == ""
   @req.response[:message].should == ""
 end
@@ -83,9 +83,9 @@
 end
 
 When /^the response to the create method is successful and well formatted$/ do
-  @req.response[:returncode].should be_true
+  @req.response[:returncode].should be true
   @req.response[:meetingID].should == @req.id
-  @req.response[:hasBeenForciblyEnded].should be_false
+  @req.response[:hasBeenForciblyEnded].should be false
   @req.response[:messageKey].should == ""
   @req.response[:message].should == ""
 
@@ -111,12 +111,12 @@
 end
 
 When /^the response to the end method is successful and well formatted$/ do
-  @req.response[:returncode].should be_true
+  @req.response[:returncode].should be true
   @req.response[:messageKey].should == "sentEndMeetingRequest"
   @req.response[:message].should_not be_empty
 end
 
 When /^the response to the get_recordings method is successful and well formatted$/ do
-  @req.response[:returncode].should be_true
+  @req.response[:returncode].should be true
   @req.response[:recordings].should == []
 end
diff --git a/features/step_definitions/end_meetings_steps.rb b/features/step_definitions/end_meetings_steps.rb
@@ -24,16 +24,16 @@
 end
 
 When /^the flag hasBeenForciblyEnded should be set$/ do
-  @req.response[:hasBeenForciblyEnded].should be_true
+  @req.response[:hasBeenForciblyEnded].should be true
 end
 
 When /^the information returned by get_meeting_info is correct$/ do
   # check only what is different in a meeting that WAS ENDED
   # the rest is checked in other scenarios
 
   @req.response = @api.get_meeting_info(@req.id, @req.mod_pass)
-  @req.response[:running].should be_false
-  @req.response[:hasBeenForciblyEnded].should be_true
+  @req.response[:running].should be false
+  @req.response[:hasBeenForciblyEnded].should be true
   @req.response[:participantCount].should == 0
   @req.response[:moderatorCount].should == 0
   @req.response[:attendees].should == []
diff --git a/features/step_definitions/recordings_steps.rb b/features/step_definitions/recordings_steps.rb
@@ -11,8 +11,8 @@
 
 When /^the meeting is set to be recorded$/ do
   @req.response = @api.get_meeting_info(@req.id, @req.mod_pass)
-  @req.response[:returncode].should be_true
-  @req.response[:recording].should be_true
+  @req.response[:returncode].should be true
+  @req.response[:recording].should be true
 end
 
 When /^the user creates a meeting without the record flag$/ do
@@ -28,8 +28,8 @@
 
 When /^the meeting is not set to be recorded$/i do
   @req.response = @api.get_meeting_info(@req.id, @req.mod_pass)
-  @req.response[:returncode].should be_true
-  @req.response[:recording].should be_false
+  @req.response[:returncode].should be true
+  @req.response[:recording].should be false
 end
 
 When /^the user calls the get_recordings method$/ do
diff --git a/spec/bigbluebutton_api_spec.rb b/spec/bigbluebutton_api_spec.rb
@@ -302,9 +302,9 @@
         before {
           api.should_receive(:send_api_request).with(:getMeetings, {}).
           and_return(flattened_response)
-          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-          formatter_mock.should_receive(:flatten_objects).with(:meetings, :meeting)
-          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_mock)
+          formatter_double = double(BigBlueButton::BigBlueButtonFormatter)
+          formatter_double.should_receive(:flatten_objects).with(:meetings, :meeting)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_double)
           BigBlueButton::BigBlueButtonFormatter.should_receive(:format_meeting).with(meeting_hash1)
           BigBlueButton::BigBlueButtonFormatter.should_receive(:format_meeting).with(meeting_hash2)
         }
@@ -381,27 +381,27 @@
     describe "#last_http_response" do
       # we test this through a #test_connection call
 
-      let(:request_mock) { mock }
+      let(:request_double) { double }
       before {
         api.should_receive(:get_url)
         # this return value will be stored in @http_response
-        api.should_receive(:send_request).and_return(request_mock)
+        api.should_receive(:send_request).and_return(request_double)
         # to return fast from #send_api_request
-        request_mock.should_receive(:body).and_return("")
+        request_double.should_receive(:body).and_return("")
         api.test_connection
       }
-      it { api.last_http_response.should == request_mock }
+      it { api.last_http_response.should == request_double }
     end
 
     describe "#last_xml_response" do
       # we test this through a #test_connection call
 
-      let(:request_mock) { mock }
+      let(:request_double) { double }
       let(:expected_xml) { "<response><returncode>SUCCESS</returncode></response>" }
       before {
         api.should_receive(:get_url)
-        api.should_receive(:send_request).and_return(request_mock)
-        request_mock.should_receive(:body).at_least(1).and_return(expected_xml)
+        api.should_receive(:send_request).and_return(request_double)
+        request_double.should_receive(:body).at_least(1).and_return(expected_xml)
         api.test_connection
       }
       it { api.last_xml_response.should == expected_xml }
@@ -503,22 +503,22 @@
       let(:data) { "any data" }
       let(:url) { "http://test-server:8080?param1=value1&checksum=12345" }
       let(:make_request) { api.send_api_request(method, params, data) }
-      let(:response_mock) { mock() } # mock of what send_request() would return
+      let(:response_double) { double() } # mock of what send_request() would return
 
       before { api.should_receive(:get_url).with(method, params).and_return([url, nil]) }
 
       context "returns an empty hash if the response body is empty" do
         before do
-          api.should_receive(:send_request).with(url, data).and_return(response_mock)
-          response_mock.should_receive(:body).and_return("")
+          api.should_receive(:send_request).with(url, data).and_return(response_double)
+          response_double.should_receive(:body).and_return("")
         end
         it { make_request.should == { } }
       end
 
       context "hashfies and validates the response body" do
         before do
-          api.should_receive(:send_request).with(url, data).and_return(response_mock)
-          response_mock.should_receive(:body).twice.and_return("response-body")
+          api.should_receive(:send_request).with(url, data).and_return(response_double)
+          response_double.should_receive(:body).twice.and_return("response-body")
         end
 
         context "checking if it has a :response key" do
@@ -536,15 +536,15 @@
         let(:response) { { :returncode => "SUCCESS" } }
         let(:formatted_response) { { :returncode => true, :messageKey => "", :message => "" } }
         before do
-          api.should_receive(:send_request).with(url, data).and_return(response_mock)
-          response_mock.should_receive(:body).twice.and_return("response-body")
+          api.should_receive(:send_request).with(url, data).and_return(response_double)
+          response_double.should_receive(:body).twice.and_return("response-body")
           BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return(response)
 
           # here starts the validation
           # doesn't test the resulting format, only that the formatter was called
-          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_mock)
-          formatter_mock.should_receive(:default_formatting).and_return(formatted_response)
+          formatter_double = double(BigBlueButton::BigBlueButtonFormatter)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_double)
+          formatter_double.should_receive(:default_formatting).and_return(formatted_response)
         end
         it { make_request }
       end
@@ -553,13 +553,13 @@
         let(:response) { { :returncode => true } }
         let(:formatted_response) { { } }
         before do
-          api.should_receive(:send_request).with(url, data).and_return(response_mock)
-          response_mock.should_receive(:body).twice.and_return("response-body")
+          api.should_receive(:send_request).with(url, data).and_return(response_double)
+          response_double.should_receive(:body).twice.and_return("response-body")
           BigBlueButton::BigBlueButtonHash.should_receive(:from_xml).with("response-body").and_return(response)
 
-          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_mock)
-          formatter_mock.should_receive(:default_formatting).and_return(formatted_response)
+          formatter_double = double(BigBlueButton::BigBlueButtonFormatter)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).with(response).and_return(formatter_double)
+          formatter_double.should_receive(:default_formatting).and_return(formatted_response)
         end
         it { expect { make_request }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
@@ -571,25 +571,25 @@
       let(:res) { Net::HTTPResponse.new(1.0, '200', 'OK') }
 
       before do
-        @http_mock = mock(Net::HTTP)
-        @http_mock.should_receive(:"open_timeout=").with(api.timeout)
-        @http_mock.should_receive(:"read_timeout=").with(api.timeout)
-        Net::HTTP.should_receive(:new).with("test-server", 8080).and_return(@http_mock)
+        @http_double = double(Net::HTTP)
+        @http_double.should_receive(:"open_timeout=").with(api.timeout)
+        @http_double.should_receive(:"read_timeout=").with(api.timeout)
+        Net::HTTP.should_receive(:new).with("test-server", 8080).and_return(@http_double)
         res.stub(:body) { "ok" }
       end
 
       context "standard case" do
-        before { @http_mock.should_receive(:get).with("/res?param1=value1&checksum=12345", {}).and_return(res) }
+        before { @http_double.should_receive(:get).with("/res?param1=value1&checksum=12345", {}).and_return(res) }
         it { api.send(:send_request, url).should == res }
       end
 
       context "handles a TimeoutError" do
-        before { @http_mock.should_receive(:get) { raise TimeoutError } }
+        before { @http_double.should_receive(:get) { raise TimeoutError } }
         it { expect { api.send(:send_request, url) }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
 
       context "handles general Exceptions" do
-        before { @http_mock.should_receive(:get) { raise Exception } }
+        before { @http_double.should_receive(:get) { raise Exception } }
         it { expect { api.send(:send_request, url) }.to raise_error(BigBlueButton::BigBlueButtonException) }
       end
 
@@ -598,7 +598,7 @@
         before {
           path = "/res?param1=value1&checksum=12345"
           opts = { 'Content-Type' => 'application/xml' }
-          @http_mock.should_receive(:post).with(path, data, opts).and_return(res)
+          @http_double.should_receive(:post).with(path, data, opts).and_return(res)
         }
         it {
           api.send(:send_request, url, data).should == res
@@ -607,7 +607,7 @@
 
       context "get with headers" do
         let(:headers_hash) { { :anything => "anything" } }
-        before { @http_mock.should_receive(:get).with("/res?param1=value1&checksum=12345", headers_hash).and_return(res) }
+        before { @http_double.should_receive(:get).with("/res?param1=value1&checksum=12345", headers_hash).and_return(res) }
         it {
           api.request_headers = headers_hash
           api.send(:send_request, url).should == res
@@ -620,7 +620,7 @@
         before {
           path = "/res?param1=value1&checksum=12345"
           opts = { 'Content-Type' => 'application/xml', :anything => "anything" }
-          @http_mock.should_receive(:post).with(path, data, opts).and_return(res)
+          @http_double.should_receive(:post).with(path, data, opts).and_return(res)
         }
         it {
           api.request_headers = headers_hash
@@ -685,11 +685,11 @@
       context "formats the response" do
         before {
           api.should_receive(:send_api_request).with(:getRecordings, anything).and_return(flattened_response)
-          formatter_mock = mock(BigBlueButton::BigBlueButtonFormatter)
-          formatter_mock.should_receive(:flatten_objects).with(:recordings, :recording)
+          formatter_double = double(BigBlueButton::BigBlueButtonFormatter)
+          formatter_double.should_receive(:flatten_objects).with(:recordings, :recording)
           BigBlueButton::BigBlueButtonFormatter.should_receive(:format_recording).with(recording1)
           BigBlueButton::BigBlueButtonFormatter.should_receive(:format_recording).with(recording2)
-          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_mock)
+          BigBlueButton::BigBlueButtonFormatter.should_receive(:new).and_return(formatter_double)
         }
         it { api.get_recordings }
       end
diff --git a/spec/bigbluebutton_formatter_spec.rb b/spec/bigbluebutton_formatter_spec.rb
