bigbluebutton_rails 0.0.4 → 0.0.5

data/spec/integration_conf.yml.example

@@ -0,0 +1,5 @@
+server:
+  name: 'Default'
+  url: 'http://myserver/bigbluebutton/api'
+  salt: 'mysalt'
+  version: '0.7'

data/spec/models/bigbluebutton_room_spec.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'spec_helper'
 
 describe BigbluebuttonRoom do
@@ -21,21 +22,20 @@ describe BigbluebuttonRoom do
     it { should have_db_column(:max_participants).of_type(:integer) }
     it { should have_db_column(:private).of_type(:boolean) }
     it { should have_db_column(:randomize_meetingid).of_type(:boolean) }
+    it { should have_db_column(:external).of_type(:boolean) }
+    it { should have_db_column(:param).of_type(:string) }
     it { should have_db_index(:server_id) }
     it { should have_db_index(:meetingid).unique(true) }
     it { should have_db_index(:voice_bridge).unique(true) }
-    it {
+    it "default values" do
       room = BigbluebuttonRoom.new
       room.private.should be_false
-    }
-    it {
-      room = BigbluebuttonRoom.new
       room.randomize_meetingid.should be_true
-    }
+      room.external.should be_false
+    end
   end
 
   context do
-
     before { Factory.create(:bigbluebutton_room) }
 
     it { should belong_to(:server) }
@@ -47,13 +47,15 @@ describe BigbluebuttonRoom do
     it { should validate_presence_of(:meetingid) }
     it { should validate_presence_of(:voice_bridge) }
     it { should validate_presence_of(:name) }
+    it { should validate_presence_of(:param) }
 
     it { should be_boolean(:private) }
     it { should be_boolean(:randomize_meetingid) }
 
     [: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].
+     :voice_bridge, :max_participants, :owner_id, :owner_type,
+     :randomize_meetingid, :param].
       each do |attribute|
       it { should allow_mass_assignment_of(attribute) }
     end
@@ -62,6 +64,7 @@ describe BigbluebuttonRoom do
     it { should validate_uniqueness_of(:meetingid) }
     it { should validate_uniqueness_of(:name) }
     it { should validate_uniqueness_of(:voice_bridge) }
+    it { should validate_uniqueness_of(:param) }
 
     it {
       room = Factory.create(:bigbluebutton_room)
@@ -73,14 +76,23 @@ describe BigbluebuttonRoom do
     it { should ensure_length_of(:attendee_password).is_at_most(16) }
     it { should ensure_length_of(:moderator_password).is_at_most(16) }
     it { should ensure_length_of(:welcome_msg).is_at_most(250) }
+    it { should ensure_length_of(:param).is_at_least(3) }
 
     # attr_accessors
     [:running, :participant_count, :moderator_count, :attendees,
-     :has_been_forcibly_ended, :start_time, :end_time].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
 
+    context ".to_param" do
+      it { should respond_to(:to_param) }
+      it {
+        r = Factory.create(:bigbluebutton_room)
+        r.to_param.should be(r.param)
+      }
+    end
+
     it { should respond_to(:is_running?) }
 
     describe "#user_role" do
@@ -93,6 +105,42 @@ describe BigbluebuttonRoom do
       it { room.user_role({ :not_password => "any" }).should == nil }
     end
 
+    describe "#instance_variables_compare" do
+      let(:room) { Factory.create(:bigbluebutton_room) }
+      let(:room2) { BigbluebuttonRoom.last }
+      it { should respond_to(:instance_variables_compare) }
+      it { room.instance_variables_compare(room2).should be_empty }
+      it "compares instance variables" do
+        room2.running = !room.running
+        room.instance_variables_compare(room2).should_not be_empty
+        room.instance_variables_compare(room2).should include(:@running)
+      end
+      it "ignores attributes" do
+        room2.private = !room.private
+        room.instance_variables_compare(room2).should be_empty
+      end
+    end
+
+    describe "#attr_equal?" do
+      before { Factory.create(:bigbluebutton_room) }
+      let(:room) { BigbluebuttonRoom.last }
+      let(:room2) { BigbluebuttonRoom.last }
+      it { should respond_to(:attr_equal?) }
+      it { room.attr_equal?(room2).should be_true }
+      it "compares instance variables" do
+        room2.running = !room.running
+        room.attr_equal?(room2).should be_false
+      end
+      it "compares attributes" do
+        room2.private = !room.private
+        room.attr_equal?(room2).should be_false
+      end
+      it "compares objects" do
+        room2 = room.clone
+        room.attr_equal?(room2).should be_false
+      end
+    end
+
     context "initializes" do
       let(:room) { BigbluebuttonRoom.new }
 
@@ -125,63 +173,38 @@ describe BigbluebuttonRoom do
       end
     end
 
+    context "param format" do
+      let(:msg) { I18n.t('bigbluebutton_rails.rooms.errors.param_format') }
+      it { should validate_format_of(:param).not_with("123 321").with_message(msg) }
+      it { should validate_format_of(:param).not_with("").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ab@c").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ab#c").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ab$c").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ab%c").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ábcd").with_message(msg) }
+      it { should validate_format_of(:param).not_with("-abc").with_message(msg) }
+      it { should validate_format_of(:param).not_with("abc-").with_message(msg) }
+      it { should validate_format_of(:param).with("_abc").with_message(msg) }
+      it { should validate_format_of(:param).with("abc_").with_message(msg) }
+      it { should validate_format_of(:param).with("abc") }
+      it { should validate_format_of(:param).with("123") }
+      it { should validate_format_of(:param).with("abc-123_d5") }
+    end
 
-
-=begin
-        context "randomizes meetingid" do
-          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.server = mocked_server
-          }
-
-          it "before calling create" do
-            room.should_receive(:random_meetingid).and_return(new_id)
-            mocked_api.should_receive(:create_meeting).
-              with(room.name, new_id, room.moderator_password,
-                   room.attendee_password, room.welcome_msg, room.dial_number,
-                   room.logout_url, room.max_participants, room.voice_bridge)
-            room.send_create
-          end
-
-          it "and tries again on error" do
-            # fails twice and them succeds
-            room.should_receive(:random_meetingid).exactly(3).times.and_return(new_id)
-            mocked_api.should_receive(:create_meeting).
-              with(room.name, new_id, room.moderator_password,
-                   room.attendee_password, room.welcome_msg, room.dial_number,
-                   room.logout_url, room.max_participants, room.voice_bridge).
-              twice.
-              and_return(fail_hash)
-            mocked_api.should_receive(:create_meeting).
-              with(room.name, new_id, room.moderator_password,
-                   room.attendee_password, room.welcome_msg, room.dial_number,
-                   room.logout_url, room.max_participants, room.voice_bridge).
-              once.
-              and_return(success_hash)
-            room.send_create
-          end
-
-          it "and limits to 10 tries" do
-            room.should_receive(:random_meetingid).exactly(11).times.and_return(new_id)
-            mocked_api.should_receive(:create_meeting).
-              with(room.name, new_id, room.moderator_password,
-                   room.attendee_password, room.welcome_msg, room.dial_number,
-                   room.logout_url, room.max_participants, room.voice_bridge).
-              exactly(10).times.
-              and_return(fail_hash)
-            room.send_create
-          end
-        end
-
+    context "sets param as the downcased parameterized name if param is" do
+      after :each do
+        @room.save.should be_true
+        @room.param.should == @room.name.downcase.parameterize
       end
-=end
-
-
+      it "nil" do
+        @room = Factory.build(:bigbluebutton_room, :param => nil,
+                              :name => "-My Name@ _Is Odd_-")
+      end
+      it "empty" do
+        @room = Factory.build(:bigbluebutton_room, :param => "",
+                              :name => "-My Name@ _Is Odd_-")
+      end
+    end
 
     context "using the api" do
       before { mock_server_and_api }
@@ -298,15 +321,6 @@ describe BigbluebuttonRoom do
 
         it { should respond_to(:send_create) }
 
-        it "send create_meeting" do
-          mocked_api.should_receive(:create_meeting).
-            with(room.name, room.meetingid, room.moderator_password,
-                 room.attendee_password, room.welcome_msg, room.dial_number,
-                 room.logout_url, room.max_participants, room.voice_bridge)
-          room.server = mocked_server
-          room.send_create
-        end
-
         it "send create_meeting" do
           mocked_api.should_receive(:create_meeting).
             with(room.name, room.meetingid, room.moderator_password,
@@ -395,9 +409,22 @@ describe BigbluebuttonRoom do
           room.server = mocked_server
           room.join_url(username, :attendee)
         end
+      end
 
+    end
+
+    context "validates passwords" do
+      context "for private rooms" do
+        let (:room) { Factory.build(:bigbluebutton_room, :private => true) }
+        it { room.should_not allow_value('').for(:moderator_password) }
+        it { room.should_not allow_value('').for(:attendee_password) }
       end
 
+      context "for public rooms" do
+        let (:room) { Factory.build(:bigbluebutton_room, :private => false) }
+        it { room.should allow_value('').for(:moderator_password) }
+        it { room.should allow_value('').for(:attendee_password) }
+      end
     end
 
   end

data/spec/models/bigbluebutton_server_spec.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'spec_helper'
 
 describe BigbluebuttonServer do
@@ -11,6 +12,7 @@ describe BigbluebuttonServer do
     it { should have_db_column(:url).of_type(:string) }
     it { should have_db_column(:salt).of_type(:string) }
     it { should have_db_column(:version).of_type(:string) }
+    it { should have_db_column(:param).of_type(:string) }
   end
 
   context do
@@ -21,15 +23,20 @@ describe BigbluebuttonServer do
     it { should validate_presence_of(:url) }
     it { should validate_presence_of(:salt) }
     it { should validate_presence_of(:version) }
+    it { should validate_presence_of(:param) }
 
     it { should allow_mass_assignment_of(:name) }
     it { should allow_mass_assignment_of(:url) }
     it { should allow_mass_assignment_of(:salt) }
-
-    it {
-      Factory.create(:bigbluebutton_server)
-      should validate_uniqueness_of(:url)
-    }
+    it { should allow_mass_assignment_of(:version) }
+    it { should allow_mass_assignment_of(:param) }
+
+    context "uniqueness of" do
+      before(:each) { Factory.create(:bigbluebutton_server) }
+      it { should validate_uniqueness_of(:url) }
+      it { should validate_uniqueness_of(:name) }
+      it { should validate_uniqueness_of(:param) }
+    end
 
     it "has associated rooms" do
       server = Factory.create(:bigbluebutton_server)
@@ -54,17 +61,63 @@ describe BigbluebuttonServer do
     it { should ensure_length_of(:name).is_at_least(1).is_at_most(500) }
     it { should ensure_length_of(:url).is_at_most(500) }
     it { should ensure_length_of(:salt).is_at_least(1).is_at_most(500) }
+    it { should ensure_length_of(:param).is_at_least(3) }
+
+    context ".to_param" do
+      it { should respond_to(:to_param) }
+      it {
+        s = Factory.create(:bigbluebutton_server)
+        s.to_param.should be(s.param)
+      }
+    end
 
-    it { should allow_value('http://demo.bigbluebutton.org/bigbluebutton/api').for(:url) }
-    it { should_not allow_value('').for(:url) }
-    it { should_not allow_value('http://demo.bigbluebutton.org').for(:url) }
-    it { should_not allow_value('demo.bigbluebutton.org/bigbluebutton/api').for(:url) }
+    context "url format" do
+      it { should allow_value('http://demo.bigbluebutton.org/bigbluebutton/api').for(:url) }
+      it { should_not allow_value('').for(:url) }
+      it { should_not allow_value('http://demo.bigbluebutton.org').for(:url) }
+      it { should_not allow_value('demo.bigbluebutton.org/bigbluebutton/api').for(:url) }
+    end
 
-    it { should allow_value('0.64').for(:version) }
-    it { should allow_value('0.7').for(:version) }
-    it { should_not allow_value('').for(:version) }
-    it { should_not allow_value('0.8').for(:version) }
-    it { should_not allow_value('0.6').for(:version) }
+    context "supported versions" do
+      it { should allow_value('0.64').for(:version) }
+      it { should allow_value('0.7').for(:version) }
+      it { should_not allow_value('').for(:version) }
+      it { should_not allow_value('0.8').for(:version) }
+      it { should_not allow_value('0.6').for(:version) }
+    end
+
+    context "param format" do
+      let(:msg) { I18n.t('bigbluebutton_rails.servers.errors.param_format') }
+      it { should validate_format_of(:param).not_with("123 321").with_message(msg) }
+      it { should validate_format_of(:param).not_with("").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ab@c").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ab#c").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ab$c").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ab%c").with_message(msg) }
+      it { should validate_format_of(:param).not_with("ábcd").with_message(msg) }
+      it { should validate_format_of(:param).not_with("-abc").with_message(msg) }
+      it { should validate_format_of(:param).not_with("abc-").with_message(msg) }
+      it { should validate_format_of(:param).with("_abc").with_message(msg) }
+      it { should validate_format_of(:param).with("abc_").with_message(msg) }
+      it { should validate_format_of(:param).with("abc") }
+      it { should validate_format_of(:param).with("123") }
+      it { should validate_format_of(:param).with("abc-123_d5") }
+    end
+
+    context "sets param as the downcased parameterized name if param is" do
+      after :each do
+        @server.save.should be_true
+        @server.param.should == @server.name.downcase.parameterize
+      end
+      it "nil" do
+        @server = Factory.build(:bigbluebutton_server, :param => nil,
+                                :name => "-My Name@ _Is Odd_-")
+      end
+      it "empty" do
+        @server = Factory.build(:bigbluebutton_server, :param => "",
+                                :name => "-My Name@ _Is Odd_-")
+      end
+    end
 
     context "has an api object" do
       let(:server) { server = Factory.build(:bigbluebutton_server) }
@@ -100,8 +153,8 @@ describe BigbluebuttonServer do
 
     context "fetching info from bbb" do
       let(:server) { Factory.create(:bigbluebutton_server) }
-      let(:room1) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room1") }
-      let(:room2) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room2") }
+      let(:room1) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room1", :randomize_meetingid => true) }
+      let(:room2) { Factory.create(:bigbluebutton_room, :server => server, :meetingid => "room2", :randomize_meetingid => true) }
       before {
         @api_mock = mock(BigBlueButton::BigBlueButtonApi)
         server.stub(:api).and_return(@api_mock)
@@ -110,9 +163,9 @@ describe BigbluebuttonServer do
       # the hashes should be exactly as returned by bigbluebutton-api-ruby to be sure we are testing it right
       let(:meetings) {
         [
-         { :meetingID => room1.meetingid, :attendeePW=>"ap", :moderatorPW=>"mp", :hasBeenForciblyEnded => false, :running => true},
-         { :meetingID => room2.meetingid, :attendeePW=>"pass", :moderatorPW=>"pass", :hasBeenForciblyEnded => true, :running => false},
-         { :meetingID => "im not in the db", :attendeePW=>"pass", :moderatorPW=>"pass", :hasBeenForciblyEnded => true, :running => true}
+         { :meetingID => room1.meetingid, :attendeePW => "ap", :moderatorPW => "mp", :hasBeenForciblyEnded => false, :running => true},
+         { :meetingID => room2.meetingid, :attendeePW => "pass", :moderatorPW => "pass", :hasBeenForciblyEnded => true, :running => false},
+         { :meetingID => "im not in the db", :attendeePW => "pass", :moderatorPW => "pass", :hasBeenForciblyEnded => true, :running => true}
         ]
       }
       let(:hash) {
@@ -134,18 +187,26 @@ describe BigbluebuttonServer do
         server.meetings[0].attendee_password.should == "ap"
         server.meetings[0].moderator_password.should == "mp"
         server.meetings[0].running.should == true
+        server.meetings[0].new_record?.should be_false
+        server.meetings[0].external.should be_false
+        server.meetings[0].randomize_meetingid.should be_true
 
         server.meetings[1].should == room2
         server.meetings[1].attendee_password.should == "pass"
         server.meetings[1].moderator_password.should == "pass"
         server.meetings[1].running.should == false
+        server.meetings[1].new_record?.should be_false
+        server.meetings[1].external.should be_false
+        server.meetings[1].randomize_meetingid.should be_true
 
         server.meetings[2].meetingid.should == "im not in the db"
         server.meetings[2].server.should == server
-        server.meetings[2].new_record?.should be_true
         server.meetings[2].attendee_password.should == "pass"
         server.meetings[2].moderator_password.should == "pass"
         server.meetings[2].running.should == true
+        server.meetings[2].new_record?.should be_false
+        server.meetings[2].external.should be_true
+        server.meetings[2].randomize_meetingid.should be_false
       end
 
     end

data/spec/rails_app/.gitignore

@@ -1,3 +1,4 @@
 config/locales/bigbluebutton_rails.en.yml
 db/migrate/*bigbluebutton_rails.rb
-db/schema.rb
+db/schema.rb
+tmp/

data/spec/rails_app/app/views/layouts/application.html.erb

@@ -3,7 +3,7 @@
 <head>
   <title>RailsApp</title>
   <%= stylesheet_link_tag :all %>
-  <%= javascript_include_tag :defaults %>
+  <%= javascript_include_tag 'application', 'jquery.min' %>
   <%= csrf_meta_tag %>
 </head>
 <body>

data/spec/rails_app/config/cucumber.yml

@@ -0,0 +1,8 @@
+<%
+rerun = File.file?('rerun.txt') ? IO.read('rerun.txt') : ""
+rerun_opts = rerun.to_s.strip.empty? ? "--format #{ENV['CUCUMBER_FORMAT'] || 'progress'} features" : "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} #{rerun}"
+std_opts = "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} --strict --tags ~@wip"
+%>
+default: <%= std_opts %> features
+wip: --tags @wip:3 --wip features
+rerun: <%= rerun_opts %> --format rerun --out rerun.txt --strict --tags ~@wip

data/spec/rails_app/config/database.yml

@@ -9,7 +9,7 @@ development:
 # Warning: The database defined as "test" will be erased and
 # re-generated from your development database when you run "rake".
 # Do not set this db to the same as development or production.
-test:
+test: &test
   adapter: sqlite3
   database: db/test.sqlite3
   pool: 5
@@ -20,3 +20,6 @@ production:
   database: db/production.sqlite3
   pool: 5
   timeout: 5000
+
+cucumber:
+  <<: *test

data/spec/rails_app/db/seeds.rb

@@ -1,7 +1,8 @@
 # This file should contain all the record creation needed to seed the database with its default values.
 # The data can then be loaded with the rake db:seed (or created alongside the db with db:setup).
-#
-# Examples:
-#
-#   cities = City.create([{ :name => 'Chicago' }, { :name => 'Copenhagen' }])
-#   Mayor.create(:name => 'Daley', :city => cities.first)
+
+file = File.join(Rails.root, "..", "integration_conf.yml")
+if File.exists? file
+  config = YAML.load_file(file)["server"]
+  BigbluebuttonServer.create!(config)
+end

data/spec/rails_app/features/manage_bigbluebutton_rooms.feature

@@ -0,0 +1,9 @@
+Feature: Manage BigBlueButton rooms
+  In order to held webconferences
+  One needs to be able to create and manage BigBlueButton rooms
+
+  Scenario: Register a new BigBlueButton room
+    Given a BigBlueButton server
+    When the user goes to the new BigBlueButton room page
+      And registers a new BigBlueButton room
+    Then he should see the information about this room

data/spec/rails_app/features/manage_bigbluebutton_servers.feature

@@ -0,0 +1,9 @@
+Feature: Manage BigBlueButton servers
+  In order to held webconferences
+  One needs to be able to create and manage BigBlueButton servers
+
+  Scenario: Register a new BigBlueButton server
+    Given a user named "test user"
+    When he goes to the new BigBlueButton server page
+      And registers a new BigBlueButton server
+    Then he should see the information about this server

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

@@ -0,0 +1,38 @@
+Given /a BigBlueButton server/i do
+  @server = Factory.create(:bigbluebutton_server_integration)
+end
+
+And /^registers a new BigBlueButton room$/i do
+  attrs = Factory.attributes_for(:bigbluebutton_room, :server => @server)
+  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]
+  check("bigbluebutton_room[private]") if attrs[:private]
+  fill_in("bigbluebutton_room[attendee_password]", :with => attrs[:attendee_password])
+  fill_in("bigbluebutton_room[moderator_password]", :with => attrs[:moderator_password])
+  fill_in("bigbluebutton_room[welcome_msg]", :with => attrs[:welcome_msg])
+  fill_in("bigbluebutton_room[logout_url]", :with => attrs[:logout_url])
+  fill_in("bigbluebutton_room[dial_number]", :with => attrs[:dial_number])
+  fill_in("bigbluebutton_room[max_participants]", :with => attrs[:max_participants])
+  check("bigbluebutton_room[external]") if attrs[:external]
+  fill_in("bigbluebutton_room[param]", :with => attrs[:param])
+  # Note: voice_bridge is generated when the BigbluebuttonRoom is created
+  click_button("Create")
+end
+
+Then /(?:|I ) should see the information about this room/ do
+  room = BigbluebuttonRoom.last
+  page_has_content(room.name)
+  page_has_content(room.meetingid)
+  page_has_content(room.randomize_meetingid)
+  page_has_content(room.private)
+  page_has_content(room.attendee_password)
+  page_has_content(room.moderator_password)
+  page_has_content(room.welcome_msg)
+  page_has_content(room.logout_url)
+  page_has_content(room.dial_number)
+  page_has_content(room.voice_bridge)
+  page_has_content(room.max_participants)
+  page_has_content(room.external)
+  page_has_content(room.param)
+end

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

@@ -0,0 +1,23 @@
+Given /a user named "(.+)"/i do |username|
+  @username = username
+  # TODO useless for now
+end
+
+And /^registers a new BigBlueButton server$/i do
+  attrs = Factory.attributes_for(:bigbluebutton_server_integration)
+  fill_in("bigbluebutton_server[name]", :with => attrs[:name])
+  fill_in("bigbluebutton_server[url]", :with => attrs[:url])
+  fill_in("bigbluebutton_server[salt]", :with => attrs[:salt])
+  fill_in("bigbluebutton_server[version]", :with => attrs[:version])
+  fill_in("bigbluebutton_server[param]", :with => attrs[:param])
+  click_button("Create")
+end
+
+Then /(?:|I ) should see the information about this server/ do
+  server = BigbluebuttonServer.last
+  page_has_content(server.name)
+  page_has_content(server.url)
+  page_has_content(server.salt)
+  page_has_content(server.version)
+  page_has_content(server.param)
+end

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

@@ -0,0 +1,3 @@
+When /(?:|I ) go(es)? to (.+) page$/i do |_, page_name|
+  visit path_to(page_name)
+end