refactor tag-related Rails tests and and migrate to RSpec

spec/models/server_spec.rb

@@ -152,6 +152,14 @@
       end
     end
 
+    context 'with any tag and no available servers' do
+      it 'throws an error' do
+        expect {
+          described_class.find_available('test-tag')
+        }.to raise_error(ApplicationRedisRecord::RecordNotFound)
+      end
+    end
+
     context 'with missing server hash' do
       before do
         # This is mostly a failsafe check
@@ -280,6 +288,152 @@
         }.to raise_error(ApplicationRedisRecord::RecordNotFound)
       end
     end
+
+    context 'with tagged servers' do
+      before do
+        RedisStore.with_connection do |redis|
+          redis.mapped_hmset('server:test-1', url: 'https://test-1.example.com/bigbluebutton/api', secret: 'test-1-secret',
+                                              tag: 'test-tag', enabled: 'true')
+          redis.sadd?('servers', 'test-1')
+          redis.sadd?('server_enabled', 'test-1')
+          redis.zadd('server_load', 1, 'test-1')
+          redis.mapped_hmset('server:test-2', url: 'https://test-2.example.com/bigbluebutton/api', secret: 'test-2-secret',
+                                              enabled: 'true')
+          redis.sadd?('servers', 'test-2')
+          redis.sadd?('server_enabled', 'test-2')
+          redis.zadd('server_load', 3, 'test-2')
+          redis.mapped_hmset('server:test-3', url: 'https://test-3.example.com/bigbluebutton/api', secret: 'test-3-secret',
+                                              enabled: 'true')
+          redis.sadd?('servers', 'test-3')
+          redis.sadd?('server_enabled', 'test-3')
+          redis.zadd('server_load', 2, 'test-3')
+        end
+      end
+
+      context 'and without argument' do
+        let(:server) { described_class.find_available }
+
+        it 'returns untagged server with lowest load' do
+          expect(server.id).to eq 'test-3'
+          expect(server.url).to eq 'https://test-3.example.com/bigbluebutton/api'
+          expect(server.secret).to eq 'test-3-secret'
+          expect(server.tag).to be_nil
+          expect(server.enabled).to be true
+          expect(server.state).to be_nil
+          expect(server.load).to eq 2
+        end
+      end
+
+      context 'and with empty tag argument' do
+        let(:server) { described_class.find_available('') }
+
+        it 'returns untagged server with lowest load' do
+          expect(server.id).to eq 'test-3'
+        end
+      end
+
+      context 'and with ! tag argument' do
+        let(:server) { described_class.find_available('!') }
+
+        it 'returns untagged server with lowest load' do
+          expect(server.id).to eq 'test-3'
+        end
+      end
+    end
+
+    context 'with differently tagged servers' do
+      let(:server) { described_class.find_available('test-tag') }
+
+      before do
+        RedisStore.with_connection do |redis|
+          redis.mapped_hmset('server:test-1', url: 'https://test-1.example.com/bigbluebutton/api', secret: 'test-1-secret',
+                                              enabled: 'true')
+          redis.sadd?('servers', 'test-1')
+          redis.sadd?('server_enabled', 'test-1')
+          redis.zadd('server_load', 1, 'test-1')
+          redis.mapped_hmset('server:test-2', url: 'https://test-2.example.com/bigbluebutton/api', secret: 'test-2-secret',
+                                              tag: 'test-tag', enabled: 'true')
+          redis.sadd?('servers', 'test-2')
+          redis.sadd?('server_enabled', 'test-2')
+          redis.zadd('server_load', 3, 'test-2')
+          redis.mapped_hmset('server:test-3', url: 'https://test-3.example.com/bigbluebutton/api', secret: 'test-3-secret',
+                                              tag: 'test-tag', enabled: 'true')
+          redis.sadd?('servers', 'test-3')
+          redis.sadd?('server_enabled', 'test-3')
+          redis.zadd('server_load', 2, 'test-3')
+          redis.mapped_hmset('server:test-4', url: 'https://test-4.example.com/bigbluebutton/api', secret: 'test-4-secret',
+                                              tag: 'wrong-tag', enabled: 'true')
+          redis.sadd?('servers', 'test-4')
+          redis.sadd?('server_enabled', 'test-4')
+          redis.zadd('server_load', 1, 'test-4')
+        end
+      end
+
+      context 'and optional tag argument' do
+        let(:server) { described_class.find_available('test-tag') }
+
+        it 'returns matching tagged server with lowest load' do
+          expect(server.id).to eq 'test-3'
+          expect(server.url).to eq 'https://test-3.example.com/bigbluebutton/api'
+          expect(server.secret).to eq 'test-3-secret'
+          expect(server.tag).to eq 'test-tag'
+          expect(server.enabled).to be true
+          expect(server.state).to be_nil
+          expect(server.load).to eq 2
+        end
+      end
+
+      context 'and required tag argument' do
+        let(:server) { described_class.find_available('test-tag!') }
+
+        it 'returns matching tagged server with lowest load' do
+          expect(server.id).to eq 'test-3'
+          expect(server.tag).to eq 'test-tag'
+        end
+      end
+    end
+
+    context 'with no matching tagged servers' do
+      before do
+        RedisStore.with_connection do |redis|
+          redis.mapped_hmset('server:test-1', url: 'https://test-1.example.com/bigbluebutton/api', secret: 'test-1-secret',
+                                              enabled: 'true')
+          redis.sadd?('servers', 'test-1')
+          redis.sadd?('server_enabled', 'test-1')
+          redis.zadd('server_load', 3, 'test-1')
+          redis.mapped_hmset('server:test-2', url: 'https://test-2.example.com/bigbluebutton/api', secret: 'test-2-secret',
+                                              tag: 'wrong-tag', enabled: 'true')
+          redis.sadd?('servers', 'test-2')
+          redis.sadd?('server_enabled', 'test-2')
+          redis.zadd('server_load', 1, 'test-2')
+          redis.mapped_hmset('server:test-3', url: 'https://test-3.example.com/bigbluebutton/api', secret: 'test-3-secret',
+                                              enabled: 'true')
+          redis.sadd?('servers', 'test-3')
+          redis.sadd?('server_enabled', 'test-3')
+          redis.zadd('server_load', 2, 'test-3')
+        end
+      end
+
+      context 'and optional tag argument' do
+        let(:server) { described_class.find_available('test-tag') }
+
+        it 'returns untagged server with lowest load' do
+          expect(server.id).to eq 'test-3'
+          expect(server.url).to eq 'https://test-3.example.com/bigbluebutton/api'
+          expect(server.secret).to eq 'test-3-secret'
+          expect(server.tag).to be_nil
+          expect(server.enabled).to be true
+          expect(server.state).to be_nil
+          expect(server.load).to eq 2
+        end
+      end
+
+      it 'raises error with specific message' do
+        expect {
+          described_class.find_available('test-tag!')
+        }.to raise_error(ApplicationRedisRecord::RecordNotFound, "Could not find any available servers with tag=test-tag.")
+      end
+    end
   end
 
   describe 'Servers load' do

spec/requests/bigbluebutton_api_controller_spec.rb

@@ -504,6 +504,16 @@
         expect(response_xml.at_xpath("/response/message").text).to(eq(expected_error.message))
       end
 
+      it "responds with specific InternalError if no servers with required tag are available in create" do
+        get bigbluebutton_api_create_url, params: { meetingID: "test-meeting-1", "meta_server-tag" => "test-tag!" }
+
+        response_xml = Nokogiri.XML(response.body)
+        expected_error = BBBErrors::InternalError.new("Could not find any available servers with tag=test-tag.")
+        expect(response_xml.at_xpath("/response/returncode").text).to(eq("FAILED"))
+        expect(response_xml.at_xpath("/response/messageKey").text).to(eq(expected_error.message_key))
+        expect(response_xml.at_xpath("/response/message").text).to(eq(expected_error.message))
+      end
+
       it "creates the meeting successfully for a get request" do
         params = { meetingID: "test-meeting-1", moderatorPW: "mp", voiceBridge: "1234567" }
 
@@ -559,6 +569,56 @@
         expect(new_server.load).to eq(7)
       end
 
+      it "with tag places the meeting on tagged server despite higher load" do
+        server2 = Server.create(url: "https://test-2.example.com/bigbluebutton/api/",
+                                secret: "test-2-secret", enabled: true, load: 1, tag: "test-tag")
+
+        params = { meetingID: "test-meeting-1", moderatorPW: "mp", voiceBridge: "1234567", "meta_server-tag" => "test-tag" }
+
+        stub_create = stub_request(:get, encode_bbb_uri("create", server2.url, server2.secret, params))
+                      .to_return(body: "<response><returncode>SUCCESS</returncode><meetingID>test-meeting-1</meetingID>
+                                        <attendeePW>ap</attendeePW><moderatorPW>mp</moderatorPW><messageKey/><message/></response>")
+
+        get bigbluebutton_api_create_url, params: params
+
+        # Reload
+        meeting = Meeting.find(params[:meetingID])
+
+        response_xml = Nokogiri.XML(response.body)
+        expect(stub_create).to have_been_requested
+        expect(response_xml.at_xpath("/response/returncode").text).to eq("SUCCESS")
+        expect(meeting.id).to eq(params[:meetingID])
+        expect(meeting.server.id).to eq(server2.id)
+        expect(meeting.server.load).to eq(2)
+        expect(meeting.server.tag).to eq("test-tag")
+      end
+
+      it "without tag places the meeting on untagged server despite higher load" do
+        server.tag = "test-tag"
+        server.save!
+        server2 = Server.create(url: "https://test-2.example.com/bigbluebutton/api/",
+                                secret: "test-2-secret", enabled: true, load: 1)
+
+        params = { meetingID: "test-meeting-1", moderatorPW: "mp", voiceBridge: "1234567" }
+
+        stub_create = stub_request(:get, encode_bbb_uri("create", server2.url, server2.secret, params))
+                      .to_return(body: "<response><returncode>SUCCESS</returncode><meetingID>test-meeting-1</meetingID>
+                                        <attendeePW>ap</attendeePW><moderatorPW>mp</moderatorPW><messageKey/><message/></response>")
+
+        get bigbluebutton_api_create_url, params: params
+
+        # Reload
+        meeting = Meeting.find(params[:meetingID])
+
+        response_xml = Nokogiri.XML(response.body)
+        expect(stub_create).to have_been_requested
+        expect(response_xml.at_xpath("/response/returncode").text).to eq("SUCCESS")
+        expect(meeting.id).to eq(params[:meetingID])
+        expect(meeting.server.id).to eq(server2.id)
+        expect(meeting.server.load).to eq(2)
+        expect(meeting.server.tag).to be_nil
+      end
+
       it "sets the duration param to MAX_MEETING_DURATION if set" do
         create_params = { meetingID: "test-meeting-1", moderatorPW: "test-password", voiceBridge: "1234567" }
         stub_params = { meetingID: "test-meeting-1", moderatorPW: "test-password", voiceBridge: "1234567", duration: 3600 }

test/models/server_test.rb

@@ -278,7 +278,7 @@ class ServerTest < ActiveSupport::TestCase
     assert_equal('test-3', server.id)
   end
 
-  test 'Server find_available with optional tag returns matching tagged server with lowest load' do
+  test 'Server find_available with tag argument returns matching tagged server with lowest load' do
     RedisStore.with_connection do |redis|
       redis.mapped_hmset('server:test-1', url: 'https://test-1.example.com/bigbluebutton/api', secret: 'test-1-secret',
                                           enabled: 'true')
@@ -310,40 +310,10 @@ class ServerTest < ActiveSupport::TestCase
     assert(server.enabled)
     assert_nil(server.state)
     assert_equal(2, server.load)
-  end
-
-  test 'Server find_available with required tag returns matching tagged server with lowest load' do
-    RedisStore.with_connection do |redis|
-      redis.mapped_hmset('server:test-1', url: 'https://test-1.example.com/bigbluebutton/api', secret: 'test-1-secret',
-                                          enabled: 'true')
-      redis.sadd?('servers', 'test-1')
-      redis.sadd?('server_enabled', 'test-1')
-      redis.zadd('server_load', 1, 'test-1')
-      redis.mapped_hmset('server:test-2', url: 'https://test-2.example.com/bigbluebutton/api', secret: 'test-2-secret',
-                                          tag: 'test-tag', enabled: 'true')
-      redis.sadd?('servers', 'test-2')
-      redis.sadd?('server_enabled', 'test-2')
-      redis.zadd('server_load', 3, 'test-2')
-      redis.mapped_hmset('server:test-3', url: 'https://test-3.example.com/bigbluebutton/api', secret: 'test-3-secret',
-                                          tag: 'test-tag', enabled: 'true')
-      redis.sadd?('servers', 'test-3')
-      redis.sadd?('server_enabled', 'test-3')
-      redis.zadd('server_load', 2, 'test-3')
-      redis.mapped_hmset('server:test-4', url: 'https://test-4.example.com/bigbluebutton/api', secret: 'test-4-secret',
-                                          tag: 'wrong-tag', enabled: 'true')
-      redis.sadd?('servers', 'test-4')
-      redis.sadd?('server_enabled', 'test-4')
-      redis.zadd('server_load', 1, 'test-4')
-    end
 
     server = Server.find_available('test-tag!')
     assert_equal('test-3', server.id)
-    assert_equal('https://test-3.example.com/bigbluebutton/api', server.url)
-    assert_equal('test-3-secret', server.secret)
     assert_equal('test-tag', server.tag)
-    assert(server.enabled)
-    assert_nil(server.state)
-    assert_equal(2, server.load)
   end
 
   test 'Server find_available with optional tag returns untagged server with lowest load if no matching tagged server available' do
@@ -375,7 +345,7 @@ class ServerTest < ActiveSupport::TestCase
     assert_equal(2, server.load)
   end
 
-  test 'Server find_available with required tag raises error if no matching tagged server available' do
+  test 'Server find_available with required tag raises error with specific message if no matching tagged server available' do
     RedisStore.with_connection do |redis|
       redis.mapped_hmset('server:test-1', url: 'https://test-1.example.com/bigbluebutton/api', secret: 'test-1-secret',
                                           enabled: 'true')
@@ -389,7 +359,7 @@ class ServerTest < ActiveSupport::TestCase
       redis.zadd('server_load', 1, 'test-2')
     end
 
-    assert_raises(ApplicationRedisRecord::RecordNotFound) do
+    assert_raises(ApplicationRedisRecord::RecordNotFound, "Could not find any available servers with tag=test-tag.") do
       Server.find_available('test-tag!')
     end
   end