bigbluebutton_rails 0.1.1 → 1.0.0

data/spec/models/bigbluebutton_room_spec.rb

@@ -13,7 +13,7 @@ describe BigbluebuttonRoom do
   it { should_not validate_presence_of(:owner_id) }
   it { should_not validate_presence_of(:owner_type) }
 
-  it { should_not validate_presence_of(:server_id) }
+  it { should validate_presence_of(:server_id) }
   it { should validate_presence_of(:meetingid) }
   it { should validate_presence_of(:voice_bridge) }
   it { should validate_presence_of(:name) }
@@ -22,10 +22,10 @@ describe BigbluebuttonRoom do
   it { should be_boolean(:private) }
   it { should be_boolean(:randomize_meetingid) }
 
-  [:name, :server_id, :meetingid, :attendee_password,
-   :moderator_password, :welcome_msg, :owner, :private, :logout_url,
-   :dial_number, :voice_bridge, :max_participants, :owner_id,
-   :owner_type, :randomize_meetingid, :param].
+  [:name, :server_id, :meetingid, :attendee_password, :moderator_password,
+   :welcome_msg, :owner, :server, :private, :logout_url, :dial_number,
+   :voice_bridge, :max_participants, :owner_id, :owner_type,
+   :randomize_meetingid, :param].
     each do |attribute|
     it { should allow_mass_assignment_of(attribute) }
   end
@@ -36,6 +36,11 @@ describe BigbluebuttonRoom do
   it { should validate_uniqueness_of(:voice_bridge) }
   it { should validate_uniqueness_of(:param) }
 
+  it {
+    room = Factory.create(:bigbluebutton_room)
+    room.server.should_not be_nil
+  }
+
   it { should ensure_length_of(:meetingid).is_at_least(1).is_at_most(100) }
   it { should ensure_length_of(:name).is_at_least(1).is_at_most(150) }
   it { should ensure_length_of(:attendee_password).is_at_most(16) }
@@ -45,8 +50,7 @@ describe BigbluebuttonRoom do
 
   # attr_accessors
   [:running, :participant_count, :moderator_count, :attendees,
-   :has_been_forcibly_ended, :start_time, :end_time,
-   :external, :server].each do |attr|
+   :has_been_forcibly_ended, :start_time, :end_time, :external].each do |attr|
     it { should respond_to(attr) }
     it { should respond_to("#{attr}=") }
   end
@@ -188,26 +192,20 @@ describe BigbluebuttonRoom do
 
       it { should respond_to(:fetch_is_running?) }
 
-      context "fetches is_running? when not running" do
-        before {
-          mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(false)
-          room.should_receive(:require_server)
-          room.server = mocked_server
-        }
-        before(:each) { room.fetch_is_running? }
-        it { room.running.should == false }
-        it { room.is_running?.should == false }
+      it "fetches is_running? when not running" do
+        mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(false)
+        room.server = mocked_server
+        room.fetch_is_running?
+        room.running.should == false
+        room.is_running?.should == false
       end
 
-      context "fetches is_running? when running" do
-        before {
-          mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(true)
-          room.should_receive(:require_server)
-          room.server = mocked_server
-        }
-        before(:each) { room.fetch_is_running? }
-        it { room.running.should == true }
-        it { room.is_running?.should == true }
+      it "fetches is_running? when running" do
+        mocked_api.should_receive(:is_meeting_running?).with(room.meetingid).and_return(true)
+        room.server = mocked_server
+        room.fetch_is_running?
+        room.running.should == true
+        room.is_running?.should == true
       end
 
     end
@@ -239,57 +237,53 @@ describe BigbluebuttonRoom do
 
       it { should respond_to(:fetch_meeting_info) }
 
-      context "fetches meeting info when the meeting is not running" do
-        before {
-          mocked_api.should_receive(:get_meeting_info).
-            with(room.meetingid, room.moderator_password).and_return(hash_info)
-          room.should_receive(:require_server)
-          room.server = mocked_server
-        }
-        before(:each) { room.fetch_meeting_info }
-        it { room.running.should == false }
-        it { room.has_been_forcibly_ended.should == false }
-        it { room.participant_count.should == 0 }
-        it { room.moderator_count.should == 0 }
-        it { room.start_time.should == nil }
-        it { room.end_time.should == nil }
-        it { room.attendees.should == [] }
+      it "fetches meeting info when the meeting is not running" do
+        mocked_api.should_receive(:get_meeting_info).
+          with(room.meetingid, room.moderator_password).and_return(hash_info)
+        room.server = mocked_server
+
+        room.fetch_meeting_info
+        room.running.should == false
+        room.has_been_forcibly_ended.should == false
+        room.participant_count.should == 0
+        room.moderator_count.should == 0
+        room.start_time.should == nil
+        room.end_time.should == nil
+        room.attendees.should == []
       end
 
-      context "fetches meeting info when the meeting is running" do
-        before {
-          mocked_api.should_receive(:get_meeting_info).
-            with(room.meetingid, room.moderator_password).and_return(hash_info2)
-          room.should_receive(:require_server)
-          room.server = mocked_server
-        }
-        before(:each) { room.fetch_meeting_info }
-        it { room.running.should == true }
-        it { room.has_been_forcibly_ended.should == false }
-        it { room.participant_count.should == 4 }
-        it { room.moderator_count.should == 2 }
-        it { room.start_time.should == DateTime.parse("Wed Apr 06 17:09:57 UTC 2011") }
-        it { room.end_time.should == nil }
-        it {
-          users.each do |att|
-            attendee = BigbluebuttonAttendee.new
-            attendee.from_hash(att)
-            room.attendees.should include(attendee)
-          end
-        }
+      it "fetches meeting info when the meeting is running" do
+        mocked_api.should_receive(:get_meeting_info).
+          with(room.meetingid, room.moderator_password).and_return(hash_info2)
+        room.server = mocked_server
+
+        room.fetch_meeting_info
+        room.running.should == true
+        room.has_been_forcibly_ended.should == false
+        room.participant_count.should == 4
+        room.moderator_count.should == 2
+        room.start_time.should == DateTime.parse("Wed Apr 06 17:09:57 UTC 2011")
+        room.end_time.should == nil
+
+        users.each do |att|
+          attendee = BigbluebuttonAttendee.new
+          attendee.from_hash(att)
+          room.attendees.should include(attendee)
+        end
       end
 
     end
 
     describe "#send_end" do
+
       it { should respond_to(:send_end) }
 
       it "send end_meeting" do
         mocked_api.should_receive(:end_meeting).with(room.meetingid, room.moderator_password)
-        room.should_receive(:require_server)
         room.server = mocked_server
         room.send_end
       end
+
     end
 
     describe "#send_create" do
@@ -305,7 +299,7 @@ describe BigbluebuttonRoom do
 
       it { should respond_to(:send_create) }
 
-      context "sends create_meeting" do
+      context "send create_meeting" do
 
         context "for a stored room" do
           before do
@@ -315,7 +309,6 @@ describe BigbluebuttonRoom do
                                   :voiceBridge => room.voice_bridge)
             mocked_api.should_receive(:create_meeting).
               with(room.name, room.meetingid, hash).and_return(hash_create)
-            room.stub(:select_server).and_return(mocked_server)
             room.server = mocked_server
             room.send_create
           end
@@ -333,7 +326,6 @@ describe BigbluebuttonRoom do
                                   :voiceBridge => new_room.voice_bridge)
             mocked_api.should_receive(:create_meeting).
               with(new_room.name, new_room.meetingid, hash).and_return(hash_create)
-            new_room.stub(:select_server).and_return(mocked_server)
             new_room.server = mocked_server
             new_room.send_create
           end
@@ -345,12 +337,13 @@ describe BigbluebuttonRoom do
       end
 
       context "randomizes meetingid" do
-        let(:fail_hash) { { :returncode => true, :meetingID => "new id", :messageKey => "duplicateWarning" } }
-        let(:success_hash) { { :returncode => true, :meetingID => "new id", :messageKey => "" } }
+        let(:fail_hash) { { :returncode => true, :meetingID => "new id",
+            :messageKey => "duplicateWarning" } }
+        let(:success_hash) { { :returncode => true, :meetingID => "new id",
+            :messageKey => "" } }
         let(:new_id) { "new id" }
         before {
           room.randomize_meetingid = true
-          room.stub(:select_server).and_return(mocked_server)
           room.server = mocked_server
         }
 
@@ -365,7 +358,7 @@ describe BigbluebuttonRoom do
         end
 
         it "and tries again on error" do
-          # fails twice and then succeds
+          # fails twice and them succeds
           room.should_receive(:random_meetingid).exactly(3).times.and_return(new_id)
           hash = hash_including(:moderatorPW => room.moderator_password, :attendeePW => room.attendee_password,
                                 :welcome  => room.welcome_msg, :dialNumber => room.dial_number,
@@ -399,72 +392,37 @@ describe BigbluebuttonRoom do
                                 :voiceBridge => room.voice_bridge)
           mocked_api.should_receive(:create_meeting).
             with(room.name, room.meetingid, hash).and_return(hash_create)
-          room.stub(:select_server).and_return(mocked_server)
           room.server = mocked_server
         end
         it { room.send_create }
       end
 
-      context "selects and requires a server" do
-        let(:another_server) { Factory.create(:bigbluebutton_server) }
-
-        context "and saves the result" do
-          before do
-            room.randomize_meetingid = false # take the shortest path inside #send_create
-            room.should_receive(:select_server).and_return(another_server)
-            room.should_receive(:require_server)
-            room.should_receive(:do_create_meeting)
-            room.server = mocked_server
-            room.send_create
-          end
-          it { BigbluebuttonRoom.find(room.id).server_id.should == another_server.id }
-        end
-
-        context "and does not save when is a new record" do
-          let(:new_room) { Factory.build(:bigbluebutton_room) }
-          before do
-            new_room.randomize_meetingid = false # take the shortest path inside #send_create
-            new_room.should_receive(:select_server).and_return(another_server)
-            new_room.should_receive(:require_server)
-            new_room.should_receive(:do_create_meeting).and_return(nil)
-            new_room.should_not_receive(:save)
-            new_room.server = mocked_server
-            new_room.send_create
-          end
-          it { new_room.new_record?.should be_true }
-        end
-      end
-
-    end # #send_create
+    end
 
     describe "#join_url" do
       let(:username) { Forgery(:name).full_name }
 
       it { should respond_to(:join_url) }
 
-      context do
-        before { room.should_receive(:require_server) }
-
-        it "with moderator role" do
-          mocked_api.should_receive(:join_meeting_url).
-            with(room.meetingid, username, room.moderator_password)
-          room.server = mocked_server
-          room.join_url(username, :moderator)
-        end
+      it "with moderator role" do
+        mocked_api.should_receive(:join_meeting_url).
+          with(room.meetingid, username, room.moderator_password)
+        room.server = mocked_server
+        room.join_url(username, :moderator)
+      end
 
-        it "with attendee role" do
-          mocked_api.should_receive(:join_meeting_url).
-            with(room.meetingid, username, room.attendee_password)
-          room.server = mocked_server
-          room.join_url(username, :attendee)
-        end
+      it "with attendee role" do
+        mocked_api.should_receive(:join_meeting_url).
+          with(room.meetingid, username, room.attendee_password)
+        room.server = mocked_server
+        room.join_url(username, :attendee)
+      end
 
-        it "without a role" do
-          mocked_api.should_receive(:join_meeting_url).
-            with(room.meetingid, username, 'pass')
-          room.server = mocked_server
-          room.join_url(username, nil, 'pass')
-        end
+      it "without a role" do
+        mocked_api.should_receive(:join_meeting_url).
+          with(room.meetingid, username, 'pass')
+        room.server = mocked_server
+        room.join_url(username, nil, 'pass')
       end
     end
 
@@ -590,48 +548,4 @@ describe BigbluebuttonRoom do
     it { should respond_to(:"full_logout_url=") }
   end
 
-  describe "#require_server" do
-    let(:room) { Factory.create(:bigbluebutton_room) }
-    it { should respond_to(:require_server) }
-
-    context "throws exception when the room has no server associated" do
-      before { room.server = nil }
-      it {
-        lambda {
-          room.send(:require_server)
-        }.should raise_error(BigbluebuttonRails::ServerRequired)
-      }
-    end
-
-    context "does nothing if the room has a server associated" do
-      before { room.server = Factory.create(:bigbluebutton_server) }
-      it {
-        lambda {
-          room.send(:require_server)
-        }.should_not raise_error(BigbluebuttonRails::ServerRequired)
-      }
-    end
-  end
-
-  describe "#select_server" do
-    let(:room) { Factory.create(:bigbluebutton_room, :server => nil) }
-    it { should respond_to(:select_server) }
-
-    context "selects the server with less rooms" do
-      before {
-        BigbluebuttonServer.destroy_all
-        s1 = Factory.create(:bigbluebutton_server)
-        @s2 = Factory.create(:bigbluebutton_server)
-        3.times{ Factory.create(:bigbluebutton_room, :server => s1) }
-        2.times{ Factory.create(:bigbluebutton_room, :server => @s2) }
-      }
-      it { room.send(:select_server).should == @s2 }
-    end
-
-    context "returns nil of there are no servers" do
-      before(:each) { BigbluebuttonServer.destroy_all }
-      it { room.send(:select_server).should == nil }
-    end
-  end
-
 end

data/spec/models/bigbluebutton_server_spec.rb

@@ -36,15 +36,15 @@ describe BigbluebuttonServer do
     server.rooms.should_not be_empty
   end
 
-  it "nullifies associated rooms" do
+  it "destroys associated rooms" do
     server = Factory.create(:bigbluebutton_server)
-    room = Factory.create(:bigbluebutton_room, :server => server)
+    Factory.create(:bigbluebutton_room, :server => server)
+    Factory.create(:bigbluebutton_room, :server => server)
     expect {
       expect {
         server.destroy
       }.to change{ BigbluebuttonServer.count }.by(-1)
-    }.to change{ BigbluebuttonRoom.count }.by(0)
-    BigbluebuttonRoom.find(room.id).server_id.should == nil
+    }.to change{ BigbluebuttonRoom.count }.by(-2)
   end
 
   it { should ensure_length_of(:name).is_at_least(1).is_at_most(500) }

data/spec/rails_app/features/activity_monitor_servers.feature

@@ -2,12 +2,6 @@ Feature: Monitor the active in the webconference servers
   To check the current status of a server
   One needs a real-time activity monitor
 
-  Scenario: View the activity monitor page
-    Given an anonymous user
-      And a real server
-    When he goes to the server activity monitor page
-    Then he should see the server activity monitor page
-
   @need-bot
   Scenario: View the list of meetings running in a server
     Given an anonymous user

data/spec/rails_app/features/create_rooms.feature

@@ -2,11 +2,6 @@ Feature: Create webconference rooms
   In order to held webconferences
   One needs to create and configure webconference rooms
 
-  Scenario: Access the page to create a new room
-    Given an anonymous user
-    When he goes to the new room page
-    Then he should see the new room page
-
   Scenario: Register a new BigBlueButton room
     Given a real server
     When the user goes to the new room page

data/spec/rails_app/features/create_servers.feature

@@ -2,18 +2,13 @@ Feature: Create webconference servers
   In order to held webconferences
   One needs to create and configure webconference servers
 
-  Scenario: Access the page to create a new server
-    Given an anonymous user
-    When he goes to the new server page
-    Then he should see the new server page
-
-  Scenario: Register a new server
+  Scenario: Register a new BigBlueButton server
     Given an anonymous user
     When he goes to the new server page
       And registers a new server
     Then he should see the information about this server
 
-  Scenario: Try to register a server with errors
+  Scenario: Try to register a BigBlueButton server with errors
     Given an anonymous user
     When he goes to the new server page
       And registers a new server with a wrong URL

data/spec/rails_app/features/edit_rooms.feature

@@ -2,13 +2,6 @@ Feature: Edit webconference rooms
   To change the information of a webconference rooms
   One needs to be able to edit and update the room
 
-  Scenario: Access the page to edit a room
-    Given an anonymous user
-      And a real server
-      And a room in this server
-    When he goes to the edit room page
-    Then he should see the edit room page
-
   Scenario: Edit data in a BigBlueButton room
     Given an anonymous user
       And a real server

data/spec/rails_app/features/edit_servers.feature

@@ -2,13 +2,7 @@ Feature: Edit webconference servers
   To change the information of a webconference server
   One needs to be able to edit and update the server
 
-  Scenario: Access the page to edit a server
-    Given an anonymous user
-      And a real server
-    When he goes to the edit server page
-    Then he should see the edit server page
-
-  Scenario: Edit data in a server
+  Scenario: Edit data in a BigBlueButton server
     Given an anonymous user
       And a real server
     When he goes to the edit server page
@@ -17,7 +11,7 @@ Feature: Edit webconference servers
     Then he should be at the show server URL
       And the server URL should be "http://test.com/bigbluebutton/api"
 
-  Scenario: Try to edit data in a server with incorrect values
+  Scenario: Try to edit data in a BigBlueButton server with incorrect values
     Given an anonymous user
       And a real server
     When he goes to the edit server page

data/spec/rails_app/features/join_rooms.feature

@@ -35,7 +35,6 @@ Feature: Join webconference rooms
       And a private room in this server
     When the user goes to the join room page
     Then he should be redirected to the invite room URL
-      And he should see the invite room page
 
   @mechanize
   Scenario: Joining a private room as a moderator

data/spec/rails_app/features/list_and_show_rooms.feature

@@ -3,24 +3,16 @@ Feature: List and show webconference rooms
   One needs to see the room in a list of rooms
     and see all the information it has stored
 
-  Scenario: View the list of rooms
+  Scenario: View the list of BigBlueButton rooms
     Given an anonymous user
       And a real server
       And 3 rooms in this server
     When he goes to the rooms index page
     Then he should see all available rooms in the list
 
-  Scenario: View all information of a room
+  Scenario: View all information of a BigBlueButton room
     Given an anonymous user
       And a real server
       And a room in this server
     When he goes to the show room page
     Then he should see all the information available for this room
-
-  Scenario: View the list of rooms for a single server
-    Given an anonymous user
-      And a real server
-      And 3 rooms in this server
-      And 2 rooms in any other server
-    When he goes to the server rooms page
-    Then he should see only the rooms from this server

data/spec/rails_app/features/step_definitions/activity_monitor_servers_step.rb

@@ -4,8 +4,8 @@ When /^(\d+) meetings running in this server$/ do |count|
   count.to_i.times do |i|
     room = Factory.create(:bigbluebutton_room, :server => @server)
     room.send_create
-    BigBlueButtonBot.new(@server.api, room.meetingid, msalt, 1,
-                         FeaturesConfig.root['timeout_bot_start'])
+    BigBlueButtonBot.new(@server.api, room.meetingid, msalt,
+                         1, FeaturesConfig.root['timeout_bot_start'])
     @rooms << room
   end
 end
@@ -16,8 +16,8 @@ When /^(\d+) meetings recently ended in this server$/ do |count|
   count.to_i.times do |i|
     room = Factory.create(:bigbluebutton_room, :server => @server)
     room.send_create
-    BigBlueButtonBot.new(@server.api, room.meetingid, msalt, 1,
-                         FeaturesConfig.root['timeout_bot_start'])
+    BigBlueButtonBot.new(@server.api, room.meetingid, msalt,
+                         1, FeaturesConfig.root['timeout_bot_start'])
     BigBlueButtonBot.finalize(room.meetingid)
     sleep 1
     @ended_rooms << room
@@ -76,12 +76,12 @@ def check_server_activity_monitor_rooms(rooms)
         has_content(room.meetingid)
 
         method = room.new_record? ? method(:doesnt_have_element) : method(:has_element)
-        method.call("a", { :href => bigbluebutton_room_path(room) })
-        method.call("a", { :href => edit_bigbluebutton_room_path(room) })
-        method.call("a", { :href => bigbluebutton_room_path(room), :"data-method" => :delete })
-        method.call("a", { :href => join_bigbluebutton_room_path(room) })
-        method.call("a", { :href => join_mobile_bigbluebutton_room_path(room) })
-        method.call("a", { :href => end_bigbluebutton_room_path(room) })
+        method.call("a", { :href => bigbluebutton_server_room_path(@server, room) })
+        method.call("a", { :href => edit_bigbluebutton_server_room_path(@server, room) })
+        method.call("a", { :href => bigbluebutton_server_room_path(@server, room), :"data-method" => :delete })
+        method.call("a", { :href => join_bigbluebutton_server_room_path(@server, room) })
+        method.call("a", { :href => join_mobile_bigbluebutton_server_room_path(@server, room) })
+        method.call("a", { :href => end_bigbluebutton_server_room_path(@server, room) })
 
         room.fetch_is_running?
         if room.is_running?

data/spec/rails_app/features/step_definitions/common_steps.rb

@@ -5,6 +5,7 @@ end
 When /^(\d+) server(s)?$/i do |count, _|
   # Note: these servers are not real, it will NOT be possible to make api requests
   #       for a real server use :bigbluebutton_server_integration
+  # Use "a real server" whenever possible
   count.to_i.times do
     Factory.create(:bigbluebutton_server)
   end
@@ -40,17 +41,14 @@ end
 When /(?:|I ) go(es)? to the (.+) page( \(no view check\))?$/i do |_, page_name, not_check|
   case page_name
   when /join external room/i
-    @params = { :meeting => @room.meetingid, :server_id => @server.id }
+    @params = { :meeting => @room.meetingid }
   end
   visit path_to(page_name, @params)
+  check_template(page_name) if not_check.nil?
 end
 
 When /see the (.+) page$/i do |page_name|
-  opts = {
-    :room => @room, :server => @server,
-    :rooms => BigbluebuttonRoom.all, :servers => BigbluebuttonServer.all
-  }
-  check_template(page_name, opts)
+  check_template(page_name)
 end
 
 When /a user named "(.+)"/i do |username|

data/spec/rails_app/features/step_definitions/create_rooms_steps.rb

@@ -1,6 +1,5 @@
 When /^registers a new room$/i do
   attrs = Factory.attributes_for(:bigbluebutton_room, :server => @server)
-  fill_in("bigbluebutton_room[server_id]", :with => attrs[:server_id])
   fill_in("bigbluebutton_room[name]", :with => attrs[:name])
   fill_in("bigbluebutton_room[meetingid]", :with => attrs[:meetingid])
   check("bigbluebutton_room[randomize_meetingid]") if attrs[:randomize_meetingid]

data/spec/rails_app/features/step_definitions/join_mobile_steps.rb

@@ -1,3 +1,5 @@
 When /^he should see the QR code and a link to join using a mobile device$/i do
-  check_template("mobile join", { :room => @room })
+  # FIXME this is already being checked in "he goes to the mobile join page"
+  #       any better ideas?
+  check_template("mobile join")
 end

data/spec/rails_app/features/step_definitions/join_rooms_steps.rb

@@ -1,13 +1,17 @@
 When /^he should see a form to join the external room$/i do
-  check_template("join external room")
+  within(form_selector(external_bigbluebutton_server_rooms_path(@server), 'post')) do
+    has_element("input", { :name => 'meeting', :type => 'hidden', :value => @room.meetingid })
+    has_element("input", { :name => 'user[name]', :type => 'text' })
+    has_element("input", { :name => 'user[password]', :type => 'password' })
+  end
 end
 
 When /^he should see his name in the user name input$/i do
   case current_url
   when /\/invite$/          # normal rooms
-    form = form_selector(join_bigbluebutton_room_path(@room), 'post')
+    form = form_selector(join_bigbluebutton_server_room_path(@server, @room), 'post')
   when /\/external(\?.*)?/  # external rooms
-    form = form_selector(external_bigbluebutton_rooms_path, 'post')
+    form = form_selector(external_bigbluebutton_server_rooms_path(@server), 'post')
   end
   within(form) do
     has_element("input", { :name => 'user[name]', :type => 'text', :value => @user.name })

data/spec/rails_app/features/step_definitions/list_and_show_rooms_steps.rb

@@ -1,18 +1,11 @@
 When /^he should see all available rooms in the list$/i do
+  # FIXME this is already being checked in "he goes to the rooms index page"
+  #       any better ideas?
   check_template("rooms index")
 end
 
 When /^he should see all the information available for this room$/i do
-  check_template("show room", { :room => @room })
-end
-
-When /^(\d+) room(s)? in any other server$/i do |count, _|
-  any_other_server = Factory.create(:bigbluebutton_server)
-  count.to_i.times do
-    Factory.create(:bigbluebutton_room, :server => any_other_server)
-  end
-end
-
-When /^he should see only the rooms from this server$/i do
-  check_template("server rooms", { :rooms => @server.rooms })
+  # FIXME this is already being checked in "he goes to the show room page"
+  #       any better ideas?
+  check_template("show room")
 end

data/spec/rails_app/features/step_definitions/list_and_show_servers_steps.rb

@@ -1,7 +1,11 @@
 When /^he should see all available servers in the list$/i do
+  # FIXME this is already being checked in "he goes to the servers index page"
+  #       any better ideas?
   check_template("servers index")
 end
 
 When /^he should see all the information available for this server$/i do
-  check_template("show server", { :server => @server })
+  # FIXME this is already being checked in "he goes to the show server page"
+  #       any better ideas?
+  check_template("show server")
 end