mumuki-laboratory 6.1.5 → 6.2.0

data/spec/models/problem_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-
-describe Problem, organization_workspace: :test do
-
-  context 'when no manual evaluation and' do
-    before { problem.manual_evaluation = false }
-
-    context 'when no test nor expectations' do
-      let(:problem) { build(:problem, test: nil, expectations: []) }
-      it { expect(problem.evaluation_criteria?).to be false }
-    end
-
-    context 'when no test but expectations' do
-      let(:problem) { build(:problem, test: nil, expectations: [{inspection: 'HasBinding', binding: 'foo'}]) }
-      it { expect(problem.evaluation_criteria?).to be true }
-    end
-
-    context 'when no expectations but test' do
-      let(:problem) { build(:problem, test: 'describe ...', expectations: []) }
-      it { expect(problem.evaluation_criteria?).to be true }
-    end
-  end
-
-  context 'when is manual evaluation and' do
-    before { problem.manual_evaluation = true }
-
-    context 'when no test nor expectations' do
-      let(:problem) { build(:problem, test: nil, expectations: []) }
-      it { expect(problem.evaluation_criteria?).to be true }
-    end
-
-  end
-
-  context 'when solving then failing' do
-    let!(:problem) { create(:problem) }
-    let!(:user) { create(:user) }
-
-    before do
-      assignment = problem.submit_solution!(user, content: 'foo')
-
-      assignment.test_results = [{title: 'foo', result: '', status: :passed}]
-      assignment.expectation_results = [{result: :passed, binding: 'foo', inspection: 'HasBinding'}]
-      assignment.status = :passed
-      assignment.save!
-
-      @assignment = problem.submit_solution!(user, content: 'bar')
-    end
-
-    it { expect(@assignment.expectation_results).to eq [] }
-    it { expect(@assignment.test_results).to eq nil }
-    it { expect(@assignment.result).to eq 'noop result' }
-    it { expect(@assignment.status).to eq :failed }
-  end
-
-  context 'when submit exercise with blank utf8 chars' do
-    let!(:problem) { create(:problem) }
-    let!(:user) { create(:user) }
-
-    before do
-      @assignment = problem.submit_solution!(user, content: "program {\n  Poner(Norte)\n}")
-    end #                                                                ▲
-    #                                                                    ╰ Blank unsupported UTF-8 char
-    it { expect(@assignment.solution).to eq "program {\n  Poner(Norte)\n}" }
-    #                                                    ▲
-    #                                                    ╰ Normalized text / No blank UTF-8 char
-  end
-
-  context 'when submit exercise with non blank utf8 chars' do
-    let!(:problem) { create(:problem) }
-    let!(:user) { create(:user) }
-
-    before do
-      @assignment = problem.submit_solution!(user, content: "semáforo")
-    end
-
-    it { expect(@assignment.solution).to eq "semáforo" }
-
-  end
-
-end

data/spec/models/query_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Mumuki::Domain::Submission::Query do
-  let!(:exercise) { create(:exercise) }
-  let(:user) { create(:user) }
-
-  before do
-    expect_any_instance_of(Challenge).to receive(:automated_evaluation_class).and_return(Mumuki::Domain::Evaluation::Automated)
-    allow_any_instance_of(Language).to receive(:run_query!).and_return(status: :passed, result: '5')
-  end
-
-  describe '#submit_query!' do
-    let!(:results) { exercise.submit_query!(user, query: 'foo', content: 'bar', cookie: ['foo', 'bar']) }
-    let(:assignment) { exercise.find_assignment_for user }
-
-    it { expect(results[:status]).to eq :passed }
-    it { expect(results[:result]).to eq '5' }
-    it { expect(assignment.solution).to eq 'bar' }
-    it { expect(assignment.status).to eq :pending }
-  end
-end

data/spec/models/question_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe Mumuki::Domain::Submission::Query, organization_workspace: :test do
-  let!(:exercise) { create(:problem) }
-  let(:student) { create(:user) }
-
-  describe '#submit_question!' do
-    let(:assignment) { exercise.find_assignment_for student }
-
-    context 'when just a question on an empty assignment is sent' do
-      before { exercise.submit_question!(student, content: 'Please help!') }
-
-      it { expect(assignment.status).to eq :pending }
-      it { expect(assignment.result).to be nil }
-
-      it { expect(assignment.solution).to be nil }
-      it { expect(assignment.messages.count).to eq 1 }
-      it { expect(assignment.submission_id).to_not be nil }
-    end
-
-    context 'when a question on a previous submission is sent' do
-      before do
-        assignment = exercise.submit_solution!(student, content: 'x = 1')
-        assignment.failed!
-        @original_submission_id = assignment.submission_id
-      end
-
-      before { exercise.submit_question!(student, content: 'Please help!') }
-
-      it { expect(assignment.status).to eq :failed }
-      it { expect(assignment.result).to eq 'noop result' }
-      it { expect(assignment.solution).to eq 'x = 1' }
-      it { expect(assignment.messages.count).to eq 1 }
-      it { expect(assignment.submission_id).to eq @original_submission_id }
-    end
-  end
-end

data/spec/models/reading_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe Reading, organization_workspace: :test do
-  let!(:reading) { create(:reading) }
-  let!(:user) { create(:user) }
-
-  let!(:result) { reading.submit_confirmation!(user) }
-
-  it { expect(result).to eq status: :passed, result: '' }
-end

data/spec/models/solution_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe Mumuki::Domain::Submission::Solution, organization_workspace: :test do
-
-  let(:user) { create(:user) }
-
-  describe '#try_submit_solution!' do
-
-    context 'when on chapter' do
-      let(:problem) { create(:problem) }
-      let!(:chapter) {
-        create(:chapter, name: 'Functional Programming', lessons: [
-          create(:lesson, exercises: [problem])
-        ]) }
-
-      before { reindex_current_organization! }
-      let!(:result) { problem.try_submit_solution! user }
-
-      it { expect(result).to eq problem.find_assignment_for(user) }
-      it { expect(result.attempts_left).to eq nil  }
-      it { expect(result.attempts_left?).to be true  }
-    end
-
-    context 'when on exam' do
-      let(:problem) { create(:problem) }
-      let!(:exam) { create(:exam, max_problem_submissions: 10, exercises: [problem]) }
-
-      before { reindex_current_organization! }
-      let(:result) { problem.try_submit_solution! user }
-
-      it { expect(result).to eq problem.find_assignment_for(user) }
-      it { expect(result.attempts_left).to eq 9  }
-      it { expect(result.attempts_left?).to be true  }
-    end
-  end
-
-  describe '#submit_solution!' do
-
-    before { expect_any_instance_of(Challenge).to receive(:automated_evaluation_class).and_return(Mumuki::Domain::Evaluation::Automated) }
-    before { expect_any_instance_of(Language).to receive(:run_tests!).and_return(bridge_response) }
-
-    context 'when results have no expectation' do
-      let(:exercise) { create(:x_equal_5_exercise) }
-      let(:assignment) { exercise.submit_solution! user }
-      let(:bridge_response) { {result: '0 failures', status: :passed} }
-
-      it { expect(assignment.status).to eq(:passed) }
-      it { expect(assignment.result).to include('0 failures') }
-    end
-
-    context 'when results have expectations' do
-      let(:exercise_with_expectations) {
-        create(:x_equal_5_exercise, expectations: [{binding: :foo, inspection: :HasComposition}]) }
-      let(:assignment) { exercise_with_expectations.submit_solution! user }
-      let(:bridge_response) { {
-          result: '0 failures',
-          status: :passed,
-          expectation_results: [binding: 'foo', inspection: 'HasBinding', result: :passed]} }
-
-      it { expect(assignment.status).to eq(:passed) }
-      it { expect(assignment.result).to include('0 failures') }
-      it { expect(assignment.expectation_results).to eq([{binding: 'foo', inspection: 'HasBinding', result: :passed}]) }
-    end
-
-  end
-end

data/spec/models/stats_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Stats do
-
-  context 'with good stats' do
-    let(:stats) { Stats.new(passed: 6, passed_with_warnings: 3, failed: 1, pending: 0) }
-    it { expect(stats.done?).to be false }
-  end
-
-
-  context 'with bad stats' do
-    let(:stats) { Stats.new(passed: 1, passed_with_warnings: 0, failed: 4, pending: 5) }
-    it { expect(stats.done?).to be false }
-  end
-end

data/spec/models/string_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe String do
-  describe 'markdown_paragraphs' do
-    it { expect("hello\nworld !\n\nbye bye".markdown_paragraphs).to eq ["hello\nworld !", 'bye bye'] }
-    it { expect("hello\nworld !\n \nbye bye".markdown_paragraphs).to eq ["hello\nworld !", 'bye bye'] }
-    it { expect("hello\nworld !\n \n\nbye bye".markdown_paragraphs).to eq ["hello\nworld !", 'bye bye'] }
-  end
-end

data/spec/models/topic_import_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Guide do
-  let!(:haskell) { create(:haskell) }
-  let!(:gobstones) { create(:gobstones) }
-
-  let!(:lesson_1) { create(:lesson, name: 'l1') }
-  let(:guide_1) { lesson_1.guide }
-
-  let!(:lesson_2) { create(:lesson, name: 'l2') }
-
-  let!(:guide_2) { create(:guide, name: 'g2') }
-  let!(:guide_3) { create(:guide, name: 'g3') }
-
-  let(:topic_json) do
-    {name: 'sample topic',
-     description: 'topic description',
-     slug: 'mumuki/mumuki-sample-topic',
-     locale: 'en',
-     lessons: [guide_2, guide_1, guide_3].map(&:slug)}
-  end
-
-  describe '#import_from_resource_h!' do
-    context 'when guide is empty' do
-      let(:topic) { create(:topic, lessons: [lesson_1, lesson_2]) }
-
-      before do
-        topic.import_from_resource_h!(topic_json)
-      end
-
-      it { expect(topic.name).to eq 'sample topic' }
-      it { expect(topic.description).to eq 'topic description' }
-      it { expect(topic.locale).to eq 'en' }
-      it { expect(topic.lessons.count).to eq 3 }
-      it { expect(topic.lessons.first.guide).to eq guide_2 }
-      it { expect(topic.lessons.second).to eq lesson_1 }
-      it { expect(topic.lessons.third.guide).to eq guide_3 }
-      it { expect(Guide.count).to eq 4 }
-      it { expect(Lesson.count).to eq 3 }
-    end
-  end
-end

data/spec/models/usage_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-describe Usage do
-
-  let!(:fundamentals) { create(:topic) }
-  let!(:functional_programming) { create(:topic) }
-  let!(:oop) { create(:topic) }
-  let!(:logic_programming) { create(:topic) }
-
-  let!(:programming) { create(:book, chapters: [
-      build(:chapter, topic: fundamentals),
-      build(:chapter, topic: functional_programming),
-      build(:chapter, topic: oop),
-      build(:chapter, topic: logic_programming),
-  ]) }
-
-  let!(:paradigms) { create(:book, chapters: [
-      build(:chapter, topic: functional_programming),
-      build(:chapter, topic: logic_programming),
-      build(:chapter, topic: oop),
-  ]) }
-
-  let!(:central) { create(:organization, name: 'central', book: programming) }
-  let!(:pdep) { create(:organization, name: 'pdep', book: paradigms) }
-
-  context 'on central' do
-    before { central.switch! }
-
-    it { expect(Topic.all.count).to eq 4 }
-    it { expect(Chapter.all.count).to eq 7 }
-    it { expect(Book.all.count).to eq 2 }
-    it { expect(Organization.all.count).to eq 2 }
-
-    it { expect(Organization.current).to eq central }
-    it { expect(central.book).to eq programming }
-
-    it { expect(programming.chapters.count).to eq 4 }
-    it { expect(programming.chapters.map(&:topic)).to eq [fundamentals, functional_programming, oop, logic_programming] }
-
-    it { expect(fundamentals.usage_in_organization).to_not be_nil }
-    it { expect(fundamentals.usage_in_organization.number).to eq 1 }
-
-    it { expect(functional_programming.usage_in_organization).to_not be_nil }
-    it { expect(functional_programming.usage_in_organization).to be_a(Chapter) }
-    it { expect(functional_programming.usage_in_organization.number).to eq 2 }
-    it { expect(oop.usage_in_organization.number).to eq 3 }
-    it { expect(logic_programming.usage_in_organization.number).to eq 4 }
-
-    it { expect(Usage.in_organization.count).to eq 4  }
-
-  end
-
-  context 'on pdep' do
-    before { pdep.switch! }
-
-    it { expect(Topic.all.count).to eq 4 }
-    it { expect(Chapter.all.count).to eq 7 }
-    it { expect(Book.all.count).to eq 2 }
-    it { expect(Organization.all.count).to eq 2 }
-
-    it { expect(Organization.current).to eq pdep }
-    it { expect(pdep.book).to eq paradigms }
-
-    it { expect(paradigms.chapters.count).to eq 3 }
-    it { expect(paradigms.chapters.map(&:topic)).to eq [functional_programming, logic_programming, oop] }
-
-    it { expect(fundamentals.usage_in_organization).to be_nil }
-
-    it { expect(functional_programming.usage_in_organization).to_not be_nil }
-    it { expect(functional_programming.usage_in_organization).to be_a(Chapter) }
-    it { expect(functional_programming.usage_in_organization.number).to eq 1 }
-    it { expect(logic_programming.usage_in_organization.number).to eq 2 }
-    it { expect(oop.usage_in_organization.number).to eq 3 }
-
-    it { expect(Usage.in_organization.count).to eq 3  }
-  end
-end

data/spec/models/user_changed_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe User, organization_workspace: :test do
-  let(:user) { User.find_by(uid: 'foo@bar.com') }
-  let(:user_json) { {
-    uid: 'foo@bar.com',
-    first_name: 'Foo',
-    last_name: 'Bar',
-    permissions: {student: 'test/example'},
-    id: 1
-  } }
-
-  context 'when new user' do
-    before { User.import_from_resource_h! user_json }
-    it { expect(user.uid).to eq 'foo@bar.com' }
-    it { expect(user.name).to eq 'Foo Bar' }
-    it { expect(user.student_here?).to be true }
-  end
-
-  context 'when user exists' do
-    let(:new_json) { {
-      uid: 'foo@bar.com',
-      first_name: 'Foo',
-      last_name: 'Baz',
-      permissions: {student: 'test/example2'},
-      id: 1
-    } }
-    before { User.import_from_resource_h! user_json }
-    before { User.import_from_resource_h! new_json }
-    it { expect(user.name).to eq 'Foo Baz' }
-    it { expect(user.student_here?).to be true }
-    it { expect(user.student? 'test/example2').to be true }
-    it { expect(user.student? 'test/example').to be false }
-  end
-end

data/spec/models/user_spec.rb

@@ -1,276 +0,0 @@
-require 'spec_helper'
-
-describe User, organization_workspace: :test do
-  describe '#clear_progress!' do
-    let(:student) { create :user }
-    let(:more_clauses) { create(:exercise, name: 'More Clauses') }
-
-    before { more_clauses.submit_solution! student, content: 'foo(X) :- not(bar(X))' }
-
-    before { student.reload.clear_progress! }
-
-    it { expect(student.reload.assignments).to be_empty }
-    it { expect(student.never_submitted?).to be true }
-  end
-  describe '#transfer_progress_to!' do
-
-    let(:codeorga) { create :organization, name: 'code.orga' }
-    let(:prologschool) { create :organization, name: 'prologschool' }
-
-    let(:your_first_program) { create(:exercise, name: 'Your First Program') }
-    let(:more_clauses) { create(:exercise, name: 'More Clauses') }
-
-    let(:two_hours_ago) { 2.hours.ago }
-
-    context 'when final user has less information than original' do
-      let!(:submission) { your_first_program.submit_solution! original, content: 'adasdsadas' }
-
-      before { original.reload.copy_progress_to! final }
-
-      let(:original) { create :user,
-                              permissions: {student: 'codeorga/*'},
-                              first_name: 'johnny',
-                              last_name: 'doe',
-                              social_id: 'auth0|123456',
-                              last_organization: codeorga }
-
-      let(:final) { create :user,
-                           permissions: Mumukit::Auth::Permissions.new,
-                           first_name: 'John',
-                           last_name: 'Doe',
-                           social_id: 'auth0|345678' }
-
-      it { expect(final.name).to eq 'John Doe' }
-      it { expect(final.social_id).to eq 'auth0|345678' }
-
-      it { expect(final.last_submission_date).to eq original.last_submission_date }
-      it { expect(final.last_organization).to eq codeorga }
-      it { expect(final.last_exercise).to eq your_first_program }
-
-      it { expect(final.permissions.as_json).to json_like({}) }
-
-      it { expect(submission.reload.submitter).to eq final }
-    end
-
-    context 'when final user has more information than original' do
-      before { more_clauses.submit_solution! final, content: 'adasdsadas' }
-      before { original.copy_progress_to! final.reload }
-
-      let(:original) { create :user,
-                              permissions: Mumukit::Auth::Permissions.new,
-                              first_name: 'johnny',
-                              last_name: 'doe',
-                              social_id: 'auth0|123456' }
-      let(:final) { create :user,
-                           permissions: {student: 'prologschool/*'},
-                           first_name: 'John',
-                           last_name: 'Doe',
-                           social_id: 'auth0|345678',
-                           last_organization: prologschool }
-
-      it { expect(final.name).to eq 'John Doe' }
-      it { expect(final.social_id).to eq 'auth0|345678' }
-
-      it { expect(final.last_submission_date).to_not be nil }
-      it { expect(final.last_organization).to eq prologschool }
-      it { expect(final.last_exercise).to eq more_clauses }
-
-      it { expect(final.permissions.as_json).to json_like student: 'prologschool/*' }
-    end
-
-    context 'when both have information, but final is newer' do
-      before { original.copy_progress_to! final }
-
-      let(:original) { create :user,
-                              permissions: {student: 'codeorga/*'},
-                              first_name: 'johnny',
-                              last_name: 'doe',
-                              social_id: 'auth0|123456',
-                              last_submission_date: 6.hours.ago,
-                              last_organization: codeorga,
-                              last_exercise: your_first_program }
-      let(:final) { create :user,
-                           permissions: {student: 'prologschool/*'},
-                           first_name: 'John',
-                           last_name: 'Doe',
-                           social_id: 'auth0|345678',
-                           last_submission_date: two_hours_ago,
-                           last_organization: prologschool,
-                           last_exercise: more_clauses }
-
-      it { expect(final.name).to eq 'John Doe' }
-      it { expect(final.social_id).to eq 'auth0|345678' }
-
-      it { expect(final.last_submission_date).to eq two_hours_ago }
-      it { expect(final.last_organization).to eq prologschool }
-      it { expect(final.last_exercise).to eq more_clauses }
-
-      it { expect(final.permissions.as_json).to json_like student: 'prologschool/*' }
-    end
-
-    context 'when both have information, but original is newer' do
-      before { original.copy_progress_to! final }
-
-      let(:original) { create :user,
-                              permissions: {student: 'codeorga/*'},
-                              first_name: 'johnny',
-                              last_name: 'doe',
-                              social_id: 'auth0|123456',
-                              last_submission_date: two_hours_ago,
-                              last_organization: codeorga,
-                              last_exercise: your_first_program }
-      let(:final) { create :user,
-                           permissions: {student: 'prologschool/*'},
-                           first_name: 'John',
-                           last_name: 'Doe',
-                           social_id: 'auth0|345678',
-                           last_submission_date: 5.hours.ago,
-                           last_organization: prologschool,
-                           last_exercise: more_clauses }
-
-      it { expect(final.name).to eq 'John Doe' }
-      it { expect(final.social_id).to eq 'auth0|345678' }
-
-      it { expect(final.last_submission_date).to eq two_hours_ago }
-      it { expect(final.last_organization).to eq codeorga }
-      it { expect(final.last_exercise).to eq your_first_program }
-
-      it { expect(final.permissions.as_json).to json_like student: 'prologschool/*' }
-    end
-  end
-
-  describe '#visit!' do
-    let(:user) { create(:user) }
-
-    before { user.visit! Organization.current }
-
-    it { expect(user.last_organization).to eq Organization.current }
-  end
-
-  describe 'roles' do
-    let(:other) { create(:organization, name: 'pdep') }
-    let(:user) { create :user, permissions: {student: 'pdep/k2001', teacher: 'test/all'} }
-
-    it { expect(user.student? 'test/all').to be true }
-    it { expect(user.student? 'pdep/k2001').to be true }
-
-    it { expect(user.teacher? 'test/all').to be true }
-    it { expect(user.teacher? 'pdep/k2001').to be false }
-  end
-
-  describe '#submissions_count' do
-    let!(:exercise_1) { create(:exercise) }
-    let!(:exercise_2) { create(:exercise) }
-    let!(:exercise_3) { create(:exercise) }
-
-    let(:user) { create(:user) }
-    context 'when there are no submissions' do
-      it { expect(user.reload.last_submission_date).to be nil }
-      it { expect(user.submitted_exercises_count).to eq 0 }
-      it { expect(user.solved_exercises_count).to eq 0 }
-      it { expect(user.submissions_count).to eq 0 }
-      it { expect(user.passed_submissions_count).to eq 0 }
-      it { expect(user.reload.last_exercise).to be_nil }
-      it { expect(user.reload.last_guide).to be_nil }
-    end
-
-    context 'when there are passed submissions' do
-      let!(:assignment_for) do
-        exercise_1.submit_solution!(user, content: '')
-        exercise_1.submit_solution!(user, content: '').passed!
-
-        exercise_2.submit_solution!(user, content: '').passed!
-
-        exercise_3.submit_solution!(user, content: '')
-        exercise_3.submit_solution!(user, content: '')
-      end
-
-      it { expect(user.reload.last_submission_date).to be > Assignment.last.created_at }
-      it { expect(user.submitted_exercises_count).to eq 3 }
-      it { expect(user.solved_exercises_count).to eq 2 }
-      it { expect(user.submissions_count).to eq 5 }
-      it { expect(user.passed_submissions_count).to eq 2 }
-      it { expect(user.reload.last_exercise).to eq exercise_3 }
-      it { expect(user.reload.last_guide).to eq exercise_3.guide }
-
-    end
-
-
-    context 'when there are only failed submissions' do
-      let!(:exercise_4) { create(:exercise) }
-
-      let!(:assignment_for) do
-        exercise_4.submit_solution!(user, content: '').failed!
-      end
-
-      it { expect(user.reload.last_exercise).to eq exercise_4 }
-      it { expect(user.reload.last_guide).to eq exercise_4.guide }
-    end
-  end
-
-
-  describe '.for_profile' do
-    let(:user) { create(:user, first_name: 'some name', last_name: 'some last name') }
-    let(:profile) { struct(uid: user.uid, first_name: nil, last_name: 'some other last name') }
-
-    before { User.for_profile profile }
-
-    it{ expect(User.find(user.id).first_name).to eq 'some name' }
-    it{ expect(User.find(user.id).last_name).to eq 'some other last name' }
-
-    describe 'notification' do
-      let(:user) { create(:user) }
-
-      context 'no changes' do
-        before { expect_any_instance_of(Mumukit::Nuntius::NotificationMode::Deaf).to_not receive(:notify_event!) }
-        it { User.for_profile profile }
-      end
-
-      context 'with changes' do
-        before { expect_any_instance_of(Mumukit::Nuntius::NotificationMode::Deaf).to receive(:notify_event!).exactly(1).times }
-        it { User.for_profile profile.to_h.merge(first_name: 'Mary').to_struct }
-        it { User.for_profile profile.to_h.merge(last_name: 'Doe').to_struct }
-      end
-
-    end
-  end
-
-  describe '#resubmit!' do
-    let(:student) { create :user }
-    let(:exercises) { FactoryBot.create_list(:exercise, 5) }
-
-    let!(:chapter) {
-      create(:chapter, lessons: [
-        create(:lesson, exercises: exercises)]) }
-
-    before { reindex_current_organization! }
-
-    before { exercises.each { |it| it.submit_solution! student, content: '' } }
-
-    it do
-      student.assignments.each { |it| expect(it).to receive(:notify!).once }
-      student.resubmit! Organization.current.name
-    end
-  end
-
-  describe '#accept_invitation!' do
-    let(:student) { create :user }
-    let(:invitation) { create :invitation, course: 'some_orga/some_course' }
-    before { student.accept_invitation! invitation }
-    it { expect(student.student? invitation.course).to be true }
-    it { expect(student.student? 'foo/bar').to be false }
-  end
-
-  describe '#currently_in_exam?' do
-    let(:student_not_in_exam) { create :user }
-    let(:student_in_exam) { create :user }
-    let(:exam) { create :exam }
-
-    before { exam.authorize! student_in_exam }
-    before { exam.authorize! student_not_in_exam }
-    before { exam.start! student_in_exam }
-
-    it { expect(student_not_in_exam.currently_in_exam?).to be false }
-    it { expect(student_in_exam.currently_in_exam?).to be true }
-  end
-end