635 lines
25 KiB
Ruby
635 lines
25 KiB
Ruby
#
|
|
# Copyright (C) 2011 - present Instructure, Inc.
|
|
#
|
|
# This file is part of Canvas.
|
|
#
|
|
# Canvas is free software: you can redistribute it and/or modify it under
|
|
# the terms of the GNU Affero General Public License as published by the Free
|
|
# Software Foundation, version 3 of the License.
|
|
#
|
|
# Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
# A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
|
|
# details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License along
|
|
# with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
|
|
require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
|
|
|
|
describe GroupsController do
|
|
before :once do
|
|
course_with_teacher(:active_all => true)
|
|
students = create_users_in_course(@course, 3, return_type: :record)
|
|
@student1, @student2, @student3 = students
|
|
@student = @student1
|
|
end
|
|
|
|
describe "GET context_index" do
|
|
it "should require authorization" do
|
|
user_session(user_factory) # logged in user_factory without course access
|
|
category1 = @course.group_categories.create(:name => "category 1")
|
|
category2 = @course.group_categories.create(:name => "category 2")
|
|
g1 = @course.groups.create(:name => "some group", :group_category => category1)
|
|
g2 = @course.groups.create(:name => "some other group", :group_category => category1)
|
|
g3 = @course.groups.create(:name => "some third group", :group_category => category2)
|
|
get 'index', :course_id => @course.id
|
|
assert_unauthorized
|
|
end
|
|
|
|
it "should assign variables" do
|
|
user_session(@teacher)
|
|
category1 = @course.group_categories.create(:name => "category 1")
|
|
category2 = @course.group_categories.create(:name => "category 2")
|
|
g1 = @course.groups.create(:name => "some group", :group_category => category1)
|
|
g2 = @course.groups.create(:name => "some other group", :group_category => category1)
|
|
g3 = @course.groups.create(:name => "some third group", :group_category => category2)
|
|
get 'index', :course_id => @course.id
|
|
expect(response).to be_success
|
|
expect(assigns[:groups]).not_to be_empty
|
|
expect(assigns[:groups].length).to eql(3)
|
|
expect(assigns[:groups] - [g1,g2,g3]).to be_empty
|
|
expect(assigns[:categories].length).to eql(2)
|
|
end
|
|
|
|
it "should return groups in sorted by group category name, then group name for student view" do
|
|
skip "requires pg_collkey on the server" if Group.connection.select_value("SELECT COUNT(*) FROM pg_proc WHERE proname='collkey'").to_i == 0
|
|
user_session(@student)
|
|
category1 = @course.group_categories.create(:name => "1")
|
|
category2 = @course.group_categories.create(:name => "2")
|
|
category3 = @course.group_categories.create(:name => "11")
|
|
groups = []
|
|
groups << @course.groups.create(:name => "11", :group_category => category1)
|
|
groups << @course.groups.create(:name => "2", :group_category => category1)
|
|
groups << @course.groups.create(:name => "1", :group_category => category1)
|
|
groups << @course.groups.create(:name => "22", :group_category => category2)
|
|
groups << @course.groups.create(:name => "2", :group_category => category2)
|
|
groups << @course.groups.create(:name => "3", :group_category => category2)
|
|
groups << @course.groups.create(:name => "4", :group_category => category3)
|
|
groups << @course.groups.create(:name => "44", :group_category => category3)
|
|
groups << @course.groups.create(:name => "4.5", :group_category => category3)
|
|
groups.each {|g| g.add_user @student, 'accepted' }
|
|
get 'index', :course_id => @course.id, :per_page => 50, :format => 'json'
|
|
expect(response).to be_success
|
|
expect(assigns[:paginated_groups]).not_to be_empty
|
|
expect(assigns[:paginated_groups].length).to eql(9)
|
|
#Check group category ordering
|
|
expect(assigns[:paginated_groups][0].group_category.name).to eql("1")
|
|
expect(assigns[:paginated_groups][1].group_category.name).to eql("1")
|
|
expect(assigns[:paginated_groups][2].group_category.name).to eql("1")
|
|
expect(assigns[:paginated_groups][3].group_category.name).to eql("2")
|
|
expect(assigns[:paginated_groups][4].group_category.name).to eql("2")
|
|
expect(assigns[:paginated_groups][5].group_category.name).to eql("2")
|
|
expect(assigns[:paginated_groups][6].group_category.name).to eql("11")
|
|
expect(assigns[:paginated_groups][7].group_category.name).to eql("11")
|
|
expect(assigns[:paginated_groups][8].group_category.name).to eql("11")
|
|
#Check group name ordering
|
|
expect(assigns[:paginated_groups][0].name).to eql("1")
|
|
expect(assigns[:paginated_groups][1].name).to eql("2")
|
|
expect(assigns[:paginated_groups][2].name).to eql("11")
|
|
expect(assigns[:paginated_groups][3].name).to eql("2")
|
|
expect(assigns[:paginated_groups][4].name).to eql("3")
|
|
expect(assigns[:paginated_groups][5].name).to eql("22")
|
|
expect(assigns[:paginated_groups][6].name).to eql("4")
|
|
expect(assigns[:paginated_groups][7].name).to eql("4.5")
|
|
expect(assigns[:paginated_groups][8].name).to eql("44")
|
|
end
|
|
end
|
|
|
|
describe "GET index" do
|
|
it 'should split up current and previous groups' do
|
|
course1 = @course
|
|
group_with_user(group_context: course1, user: @student, active_all: true)
|
|
group1 = @group
|
|
|
|
course_with_teacher(active_all: true)
|
|
course2 = @course
|
|
|
|
course2.soft_conclude!
|
|
course2.save!
|
|
|
|
create_enrollments(course2, [@student])
|
|
group_with_user(group_context: course2, user: @student, active_all: true)
|
|
group2 = @group
|
|
|
|
user_session(@student)
|
|
|
|
get 'index'
|
|
expect(assigns[:current_groups]).to eq([group1])
|
|
expect(assigns[:previous_groups]).to eq([group2])
|
|
end
|
|
|
|
it 'should not show restricted previous groups' do
|
|
group_with_user(group_context: @course, user: @student, active_all: true)
|
|
|
|
@course.soft_conclude!
|
|
@course.restrict_student_past_view = true
|
|
@course.save!
|
|
|
|
user_session(@student)
|
|
|
|
get 'index'
|
|
expect(assigns[:current_groups]).to eq([])
|
|
expect(assigns[:previous_groups]).to eq([])
|
|
end
|
|
|
|
it 'should put groups in courses in terms concluded for students in "previous groups"' do
|
|
@course.enrollment_term.set_overrides(@course.account, 'StudentEnrollment' => {end_at: 1.week.ago})
|
|
group_with_user(group_context: @course, user: @student, active_all: true)
|
|
user_session(@student)
|
|
get 'index'
|
|
expect(assigns[:current_groups]).to eq([])
|
|
expect(assigns[:previous_groups]).to eq([@group])
|
|
end
|
|
|
|
describe 'pagination' do
|
|
before :once do
|
|
group_with_user(:group_context => @course, :user => @student, :active_all => true)
|
|
group_with_user(:group_context => @course, :user => @student, :active_all => true)
|
|
end
|
|
|
|
before :each do
|
|
user_session(@student)
|
|
end
|
|
|
|
it "should not paginate non-json" do
|
|
get 'index', :per_page => 1
|
|
expect(assigns[:current_groups]).to eq @student.current_groups.by_name
|
|
expect(response.headers['Link']).to be_nil
|
|
end
|
|
|
|
it "should paginate json" do
|
|
get 'index', :format => 'json', :per_page => 1
|
|
expect(assigns[:groups]).to eq [@student.current_groups.by_name.first]
|
|
expect(response.headers['Link']).not_to be_nil
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "GET show" do
|
|
it "should require authorization" do
|
|
@group = Account.default.groups.create!(:name => "some group")
|
|
get 'show', :id => @group.id
|
|
expect(assigns[:group]).to eql(@group)
|
|
assert_unauthorized
|
|
end
|
|
|
|
it "should assign variables" do
|
|
@group = Account.default.groups.create!(:name => "some group")
|
|
@user = user_model
|
|
user_session(@user)
|
|
@group.add_user(@user)
|
|
get 'show', :id => @group.id
|
|
expect(response).to be_success
|
|
expect(assigns[:group]).to eql(@group)
|
|
expect(assigns[:context]).to eql(@group)
|
|
expect(assigns[:stream_items]).to eql([])
|
|
end
|
|
|
|
it "should allow user to join self-signup groups" do
|
|
user_session(@student)
|
|
category1 = @course.group_categories.create!(:name => "category 1")
|
|
category1.configure_self_signup(true, false)
|
|
category1.save!
|
|
g1 = @course.groups.create!(:name => "some group", :group_category => category1)
|
|
|
|
get 'show', :course_id => @course.id, :id => g1.id, :join => 1
|
|
g1.reload
|
|
expect(g1.users.map(&:id)).to include @student.id
|
|
end
|
|
|
|
it "should allow user to leave self-signup groups" do
|
|
user_session(@student)
|
|
category1 = @course.group_categories.create!(:name => "category 1")
|
|
category1.configure_self_signup(true, false)
|
|
category1.save!
|
|
g1 = @course.groups.create!(:name => "some group", :group_category => category1)
|
|
g1.add_user(@student)
|
|
|
|
get 'show', :course_id => @course.id, :id => g1.id, :leave => 1
|
|
g1.reload
|
|
expect(g1.users.map(&:id)).not_to include @student.id
|
|
end
|
|
|
|
it "should allow user to join student organized groups" do
|
|
user_session(@student)
|
|
category1 = GroupCategory.student_organized_for(@course)
|
|
g1 = @course.groups.create!(:name => "some group", :group_category => category1, :join_level => "parent_context_auto_join")
|
|
|
|
get 'show', :course_id => @course.id, :id => g1.id, :join => 1
|
|
g1.reload
|
|
expect(g1.users.map(&:id)).to include @student.id
|
|
end
|
|
|
|
it "should allow user to leave student organized groups" do
|
|
user_session(@student)
|
|
category1 = @course.group_categories.create!(:name => "category 1", :role => "student_organized")
|
|
g1 = @course.groups.create!(:name => "some group", :group_category => category1)
|
|
g1.add_user(@student)
|
|
|
|
get 'show', :course_id => @course.id, :id => g1.id, :leave => 1
|
|
g1.reload
|
|
expect(g1.users.map(&:id)).not_to include @student.id
|
|
end
|
|
|
|
it "should allow teachers to view after conclusion" do
|
|
@teacher.enrollments.first.conclude
|
|
user_session(@teacher)
|
|
category = @course.group_categories.create(:name => "category")
|
|
group = @course.groups.create(:name => "some group", :group_category => category)
|
|
|
|
get 'show', :id => group.id
|
|
|
|
expect(response).to be_success
|
|
expect(assigns[:group]).to eql(group)
|
|
end
|
|
end
|
|
|
|
describe "GET new" do
|
|
it "should require authorization" do
|
|
@group = @course.groups.create!(:name => "some group")
|
|
get 'new', :course_id => @course.id
|
|
assert_unauthorized
|
|
end
|
|
end
|
|
|
|
describe "POST add_user" do
|
|
it "should require authorization" do
|
|
@group = Account.default.groups.create!(:name => "some group")
|
|
post 'add_user', :group_id => @group.id
|
|
assert_unauthorized
|
|
end
|
|
|
|
it "should add user" do
|
|
user_session(@teacher)
|
|
@group = @course.groups.create!(:name => "PG 1", :group_category => @category)
|
|
@user = user_factory(active_all: true)
|
|
post 'add_user', :group_id => @group.id, :user_id => @user.id
|
|
expect(response).to be_success
|
|
expect(assigns[:membership]).not_to be_nil
|
|
expect(assigns[:membership].user).to eql(@user)
|
|
end
|
|
|
|
it "should check user section in restricted self-signup category" do
|
|
user_session(@teacher)
|
|
section1 = @course.course_sections.create
|
|
section2 = @course.course_sections.create
|
|
user1 = section1.enroll_user(user_model, 'StudentEnrollment').user
|
|
user2 = section2.enroll_user(user_model, 'StudentEnrollment').user
|
|
group_category = @course.group_categories.build(:name => "My Category")
|
|
group_category.configure_self_signup(true, true)
|
|
group_category.save
|
|
group = group_category.groups.create(:context => @course)
|
|
group.add_user(user1)
|
|
|
|
post 'add_user', :group_id => group.id, :user_id => user2.id
|
|
expect(response).not_to be_success
|
|
expect(assigns[:membership]).not_to be_nil
|
|
expect(assigns[:membership].user).to eql(user2)
|
|
expect(assigns[:membership].errors[:user_id]).not_to be_nil
|
|
end
|
|
end
|
|
|
|
describe "DELETE remove_user" do
|
|
it "should require authorization" do
|
|
@group = Account.default.groups.create!(:name => "some group")
|
|
@user = user_factory(active_all: true)
|
|
@group.add_user(@user)
|
|
delete 'remove_user', :group_id => @group.id, :user_id => @user.id, :id => @user.id
|
|
assert_unauthorized
|
|
end
|
|
|
|
it "should remove user" do
|
|
user_session(@teacher)
|
|
@group = @course.groups.create!(:name => "PG 1", :group_category => @category)
|
|
@group.add_user(@user)
|
|
delete 'remove_user', :group_id => @group.id, :user_id => @user.id, :id => @user.id
|
|
expect(response).to be_success
|
|
@group.reload
|
|
expect(@group.users).to be_empty
|
|
end
|
|
end
|
|
|
|
describe "POST create" do
|
|
it "should require authorization" do
|
|
post 'create', :course_id => @course.id, :group => {:name => "some group"}
|
|
assert_unauthorized
|
|
end
|
|
|
|
it "should create new group" do
|
|
user_session(@teacher)
|
|
post 'create', :course_id => @course.id, :group => {:name => "some group"}
|
|
expect(response).to be_redirect
|
|
expect(assigns[:group]).not_to be_nil
|
|
expect(assigns[:group].name).to eql("some group")
|
|
end
|
|
|
|
it "should honor group[group_category_id] when permitted" do
|
|
user_session(@teacher)
|
|
group_category = @course.group_categories.create(:name => 'some category')
|
|
post 'create', :course_id => @course.id, :group => {:name => "some group", :group_category_id => group_category.id}
|
|
expect(response).to be_redirect
|
|
expect(assigns[:group]).not_to be_nil
|
|
expect(assigns[:group].group_category).to eq group_category
|
|
end
|
|
|
|
it "should not honor group[group_category_id] when not permitted" do
|
|
user_session(@student)
|
|
group_category = @course.group_categories.create(:name => 'some category')
|
|
post 'create', :course_id => @course.id, :group => {:name => "some group", :group_category_id => group_category.id}
|
|
expect(response).to be_redirect
|
|
expect(assigns[:group]).not_to be_nil
|
|
expect(assigns[:group].group_category).to eq GroupCategory.student_organized_for(@course)
|
|
end
|
|
|
|
it "should fail when group[group_category_id] would be honored but doesn't exist" do
|
|
user_session(@student)
|
|
group_category = @course.group_categories.create(:name => 'some category')
|
|
post 'create', :course_id => @course.id, :group => {:name => "some group", :group_category_id => 11235}
|
|
expect(response).not_to be_success
|
|
end
|
|
|
|
describe "quota" do
|
|
before do
|
|
Setting.set('group_default_quota', 11.megabytes)
|
|
end
|
|
|
|
context "teacher" do
|
|
before do
|
|
user_session(@teacher)
|
|
end
|
|
|
|
it "should ignore the storage_quota_mb parameter" do
|
|
post 'create', :course_id => @course.id, :group => {:name => "a group", :storage_quota_mb => 22}
|
|
expect(assigns[:group].storage_quota_mb).to eq 11
|
|
end
|
|
end
|
|
|
|
context "account admin" do
|
|
before do
|
|
account_admin_user
|
|
user_session(@admin)
|
|
end
|
|
|
|
it "should set the storage_quota_mb parameter" do
|
|
post 'create', :course_id => @course.id, :group => {:name => "a group", :storage_quota_mb => 22}
|
|
expect(assigns[:group].storage_quota_mb).to eq 22
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "PUT update" do
|
|
it "should require authorization" do
|
|
@group = @course.groups.create!(:name => "some group")
|
|
put 'update', :course_id => @course.id, :id => @group.id, :group => {:name => "new name"}
|
|
assert_unauthorized
|
|
end
|
|
|
|
it "should update group" do
|
|
user_session(@teacher)
|
|
@group = @course.groups.create!(:name => "some group")
|
|
put 'update', :course_id => @course.id, :id => @group.id, :group => {:name => "new name"}
|
|
expect(response).to be_redirect
|
|
expect(assigns[:group]).to eql(@group)
|
|
expect(assigns[:group].name).to eql("new name")
|
|
end
|
|
|
|
it "should honor group[group_category_id]" do
|
|
user_session(@teacher)
|
|
group_category = @course.group_categories.create(:name => 'some category')
|
|
@group = @course.groups.create!(:name => "some group")
|
|
put 'update', :course_id => @course.id, :id => @group.id, :group => {:group_category_id => group_category.id}
|
|
expect(response).to be_redirect
|
|
expect(assigns[:group]).to eql(@group)
|
|
expect(assigns[:group].group_category).to eq group_category
|
|
end
|
|
|
|
it "should fail when group[group_category_id] doesn't exist" do
|
|
user_session(@teacher)
|
|
group_category = @course.group_categories.create(:name => 'some category')
|
|
@group = @course.groups.create!(:name => "some group", :group_category => group_category)
|
|
put 'update', :course_id => @course.id, :id => @group.id, :group => {:group_category_id => 11235}
|
|
expect(response).not_to be_success
|
|
end
|
|
|
|
describe "quota" do
|
|
before :once do
|
|
@group = @course.groups.build(:name => "teh gruop")
|
|
@group.storage_quota_mb = 11
|
|
@group.save!
|
|
end
|
|
|
|
context "teacher" do
|
|
before do
|
|
user_session(@teacher)
|
|
end
|
|
|
|
it "should ignore the quota parameter" do
|
|
put 'update', :course_id => @course.id, :id => @group.id, :group => {:name => 'the group', :storage_quota_mb => 22}
|
|
@group.reload
|
|
expect(@group.name).to eq 'the group'
|
|
expect(@group.storage_quota_mb).to eq 11
|
|
end
|
|
end
|
|
|
|
context "account admin" do
|
|
before do
|
|
account_admin_user
|
|
user_session(@admin)
|
|
end
|
|
|
|
it "should update group quota" do
|
|
put 'update', :course_id => @course.id, :id => @group.id, :group => {:name => 'the group', :storage_quota_mb => 22}
|
|
@group.reload
|
|
expect(@group.name).to eq 'the group'
|
|
expect(@group.storage_quota_mb).to eq 22
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "DELETE destroy" do
|
|
it "should require authorization" do
|
|
@group = @course.groups.create!(:name => "some group")
|
|
delete 'destroy', :course_id => @course.id, :id => @group.id
|
|
assert_unauthorized
|
|
end
|
|
|
|
it "should delete group" do
|
|
user_session(@teacher)
|
|
@group = @course.groups.create!(:name => "some group")
|
|
delete 'destroy', :course_id => @course.id, :id => @group.id
|
|
expect(assigns[:group]).to eql(@group)
|
|
expect(assigns[:group]).not_to be_frozen
|
|
expect(assigns[:group]).to be_deleted
|
|
expect(@course.groups).to be_include(@group)
|
|
expect(@course.groups.active).not_to be_include(@group)
|
|
end
|
|
end
|
|
|
|
describe "GET 'unassigned_members'" do
|
|
it "should include all users if the category is student organized" do
|
|
user_session(@teacher)
|
|
u1 = @student1
|
|
u2 = @student2
|
|
u3 = @student3
|
|
|
|
group = @course.groups.create(:name => "Group 1", :group_category => GroupCategory.student_organized_for(@course))
|
|
group.add_user(u1)
|
|
group.add_user(u2)
|
|
|
|
get 'unassigned_members', :course_id => @course.id, :category_id => group.group_category.id
|
|
expect(response).to be_success
|
|
data = json_parse
|
|
expect(data).not_to be_nil
|
|
expect(data['users'].map{ |u| u['user_id'] }.sort).
|
|
to eq [u1, u2, u3].map{ |u| u.id }.sort
|
|
end
|
|
|
|
it "should include only users not in a group in the category otherwise" do
|
|
user_session(@teacher)
|
|
u1 = @student1
|
|
u2 = @student2
|
|
u3 = @student3
|
|
|
|
group_category1 = @course.group_categories.create(:name => "Group Category 1")
|
|
group1 = @course.groups.create(:name => "Group 1", :group_category => group_category1)
|
|
group1.add_user(u1)
|
|
|
|
group_category2 = @course.group_categories.create(:name => "Group Category 2")
|
|
group2 = @course.groups.create(:name => "Group 1", :group_category => group_category2)
|
|
group2.add_user(u2)
|
|
|
|
group_category3 = @course.group_categories.create(:name => "Group Category 3")
|
|
group3 = @course.groups.create(:name => "Group 1", :group_category => group_category3)
|
|
group3.add_user(u2)
|
|
group3.add_user(u3)
|
|
|
|
get 'unassigned_members', :course_id => @course.id, :category_id => group1.group_category.id
|
|
expect(response).to be_success
|
|
data = json_parse
|
|
expect(data).not_to be_nil
|
|
expect(data['users'].map{ |u| u['user_id'] }.sort).
|
|
to eq [u2, u3].map{ |u| u.id }.sort
|
|
|
|
get 'unassigned_members', :course_id => @course.id, :category_id => group2.group_category.id
|
|
expect(response).to be_success
|
|
data = json_parse
|
|
expect(data).not_to be_nil
|
|
expect(data['users'].map{ |u| u['user_id'] }.sort).
|
|
to eq [u1, u3].map{ |u| u.id }.sort
|
|
|
|
get 'unassigned_members', :course_id => @course.id, :category_id => group3.group_category.id
|
|
expect(response).to be_success
|
|
data = json_parse
|
|
expect(data).not_to be_nil
|
|
expect(data['users'].map{ |u| u['user_id'] }).to eq [ u1.id ]
|
|
end
|
|
|
|
it "should include the users' sections when available" do
|
|
user_session(@teacher)
|
|
u1 = @student1
|
|
u2 = @student2
|
|
|
|
group = @course.groups.create(:name => "Group 1", :group_category => GroupCategory.student_organized_for(@course))
|
|
group.add_user(u1)
|
|
|
|
get 'unassigned_members', :course_id => @course.id, :category_id => group.group_category.id
|
|
data = json_parse
|
|
expect(data['users'].first['sections'].first['section_id']).to eq @course.default_section.id
|
|
expect(data['users'].first['sections'].first['section_code']).to eq @course.default_section.section_code
|
|
end
|
|
end
|
|
|
|
describe "GET 'context_group_members'" do
|
|
it "should include the users' sections when available" do
|
|
user_session(@teacher)
|
|
u1 = @student1
|
|
group = @course.groups.create(:name => "Group 1", :group_category => GroupCategory.student_organized_for(@course))
|
|
group.add_user(u1)
|
|
|
|
get 'context_group_members', :group_id => group.id
|
|
data = json_parse
|
|
expect(data.first['sections'].first['section_id']).to eq @course.default_section.id
|
|
expect(data.first['sections'].first['section_code']).to eq @course.default_section.section_code
|
|
end
|
|
|
|
it "should require :read_roster permission" do
|
|
u1 = @student1
|
|
u2 = @student2
|
|
group = @course.groups.create(:name => "Group 1")
|
|
group.add_user(u1)
|
|
|
|
# u1 in the group has :read_roster permission
|
|
user_session(u1)
|
|
get 'context_group_members', :group_id => group.id
|
|
expect(response).to be_success
|
|
|
|
# u2 outside the group doesn't have :read_roster permission, since the
|
|
# group isn't self-signup and is invitation only (clear controller
|
|
# context permission cache, though)
|
|
controller.instance_variable_set(:@context_all_permissions, nil)
|
|
user_session(u2)
|
|
get 'context_group_members', :group_id => group.id
|
|
expect(response).not_to be_success
|
|
end
|
|
end
|
|
|
|
describe "GET 'public_feed.atom'" do
|
|
before :once do
|
|
group_with_user(:active_all => true)
|
|
@group.discussion_topics.create!(:title => "hi", :message => "intros", :user => @user)
|
|
end
|
|
|
|
it "should require authorization" do
|
|
get 'public_feed', :format => 'atom', :feed_code => @group.feed_code + 'x'
|
|
expect(assigns[:problem]).to match /The verification code is invalid/
|
|
end
|
|
|
|
it "should include absolute path for rel='self' link" do
|
|
get 'public_feed', :format => 'atom', :feed_code => @group.feed_code
|
|
feed = Atom::Feed.load_feed(response.body) rescue nil
|
|
expect(feed).not_to be_nil
|
|
expect(feed.links.first.rel).to match(/self/)
|
|
expect(feed.links.first.href).to match(/http:\/\//)
|
|
end
|
|
|
|
it "should include an author for each entry" do
|
|
get 'public_feed', :format => 'atom', :feed_code => @group.feed_code
|
|
feed = Atom::Feed.load_feed(response.body) rescue nil
|
|
expect(feed).not_to be_nil
|
|
expect(feed.entries).not_to be_empty
|
|
expect(feed.entries.all?{|e| e.authors.present?}).to be_truthy
|
|
end
|
|
end
|
|
|
|
describe "GET 'accept_invitation'" do
|
|
before :once do
|
|
@communities = GroupCategory.communities_for(Account.default)
|
|
group_model(:group_category => @communities)
|
|
user_factory(active_user: true)
|
|
@membership = @group.add_user(@user, 'invited', false)
|
|
end
|
|
|
|
before :each do
|
|
user_session(@user)
|
|
end
|
|
|
|
it "should successfully create invitations" do
|
|
get 'accept_invitation', :group_id => @group.id, :uuid => @membership.uuid
|
|
@group.reload
|
|
expect(@group.has_member?(@user)).to be_truthy
|
|
expect(@group.group_memberships.where(:workflow_state => "invited").count).to eq 0
|
|
end
|
|
|
|
it "should reject an invalid invitation uuid" do
|
|
get 'accept_invitation', :group_id => @group.id, :uuid => @membership.uuid + "x"
|
|
@group.reload
|
|
expect(@group.has_member?(@user)).to be_falsey
|
|
expect(@group.group_memberships.where(:workflow_state => "invited").count).to eq 1
|
|
end
|
|
end
|
|
end
|