mumuki-laboratory 7.9.2 → 7.10.0

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-7082a83493eb/spec/models/event_publishing_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'rspec/mocks'
-
-describe 'events' do
-  let(:exercise) { create(:exercise) }
-  let(:assignment) { create(:assignment, exercise: exercise) }
-
-  before { organization.switch! }
-  before { create(:chapter, lessons: [ create(:lesson, exercises: [ exercise ]) ]) }
-  before { reindex_current_organization! }
-
-  describe '#notify!' do
-    let!(:organization) { create(:organization, name: 'pdep') }
-    before { expect_any_instance_of(Mumukit::Nuntius::NotificationMode::Deaf).to receive(:notify!) }
-    before { organization.switch! }
-
-    it { expect { assignment.notify! }.to_not raise_error }
-  end
-
-  describe 'protect in central book' do
-    let!(:organization) { create(:organization, name: 'central') }
-    before { expect_any_instance_of(Mumukit::Nuntius::NotificationMode::Deaf).to receive(:notify!) }
-    before { organization.switch! }
-
-    it { expect { assignment.notify! }.to_not raise_error }
-  end
-
-  describe 'submit_solution!' do
-    let!(:organization) { create(:organization, name: 'pdep') }
-    before { expect_any_instance_of(Mumukit::Nuntius::NotificationMode::Deaf).to receive(:notify!) }
-    before { organization.switch! }
-    let(:user) { create(:user) }
-
-    it { expect { exercise.submit_solution! user }.to_not raise_error }
-  end
-end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-7082a83493eb/spec/models/exam_spec.rb

@@ -1,205 +0,0 @@
-require 'spec_helper'
-
-describe Exam, organization_workspace: :test do
-  let(:user) { create(:user) }
-  let(:other_user) { create(:user) }
-  let(:course) { create(:course, slug: 'test/foo') }
-
-  describe '#upsert' do
-    let(:guide) { create(:guide) }
-    let(:exam_json) { {eid: '1', slug: guide.slug, start_time: 5.minutes.ago, end_time: 10.minutes.since, duration: 150, language: 'haskell', name: 'foo', uids: [], organization: 'test', course: course.slug, passing_criterion: {type: 'none'}} }
-    let!(:exam) { Exam.import_from_resource_h! exam_json }
-    context 'when new exam and the guide is the same' do
-      let(:guide2) { create(:guide) }
-      let(:exam_json2) { {eid: '2', slug: guide.slug, start_time: 5.minutes.ago, end_time: 10.minutes.since, duration: 150, language: 'haskell', name: 'foo', uids: [], organization: 'test', course: course.slug, passing_criterion: {type: 'percentage', value: 75}} }
-      let!(:exam2) { Exam.import_from_resource_h! exam_json2 }
-      context 'and the organization is the same' do
-        it { expect(Exam.count).to eq 1 }
-        it { expect(Usage.where(item: guide, parent_item: exam).count).to eq 0 }
-        it { expect(Usage.where(item: guide, parent_item: exam2).count).to eq 1 }
-        it { expect(exam2.passing_criterion_type).to eq 'percentage' }
-        it { expect(exam2.passing_criterion_value).to eq 75 }
-        it { expect(ExamAuthorization.where(exam: exam).count).to eq 0 }
-      end
-    end
-
-  end
-
-  describe '#validate_accessible_for!' do
-    context 'not enabled' do
-      let(:exam) { create(:exam, start_time: 5.minutes.since, end_time: 10.minutes.since, course: course) }
-
-      it { expect(exam.enabled?).to be false }
-
-      context 'not authorized' do
-        it { expect { exam.validate_accessible_for! user }.to raise_error(Mumuki::Domain::ForbiddenError) }
-      end
-
-      context 'authorized' do
-        it { expect(exam.enabled?).to be false }
-      end
-    end
-
-    context 'enabled' do
-      let(:exam) { create(:exam, start_time: 5.minutes.ago, end_time: 10.minutes.since, course: course) }
-
-      it { expect(exam.enabled?).to be true }
-
-      context 'not authorized' do
-        it { expect { exam.validate_accessible_for! user }.to raise_error(Mumuki::Domain::ForbiddenError) }
-      end
-
-      context 'authorized' do
-        before { exam.authorize! user }
-
-        it { expect { exam.validate_accessible_for! user }.to_not raise_error }
-        it { expect { exam.validate_accessible_for! other_user }.to raise_error(Mumuki::Domain::ForbiddenError) }
-      end
-
-      context 'import_from_json' do
-        let(:user) { create(:user, uid: 'auth0|1') }
-        let(:user2) { create(:user, uid: 'auth0|2') }
-        let(:guide) { create(:guide) }
-        let(:duration) { 150 }
-        let(:exam_json) { {eid: '1', slug: guide.slug, start_time: 5.minutes.ago, end_time: 10.minutes.since, duration: duration, language: 'haskell', name: 'foo', uids: [user.uid], organization: 'test', course: course.slug, passing_criterion_type: 'none'} }
-        before { Exam.import_from_resource_h! exam_json }
-
-        context 'new exam' do
-          it { expect(Exam.count).to eq 1 }
-          it { expect { Exam.find_by(classroom_id: '1').validate_accessible_for! user }.to_not raise_error }
-          it { expect(Usage.where(organization: Organization.current, item: guide).count).to eq 1 }
-          it { expect(guide.usage_in_organization).to be_a Exam }
-        end
-
-        context 'new exam, no duration' do
-          let(:duration) { nil }
-          it { expect(guide.usage_in_organization).to be_a Exam }
-        end
-
-        context 'existing exam' do
-          let(:exam_json2) { {eid: '1', slug: guide.slug, start_time: 5.minutes.ago, end_time: 10.minutes.since, duration: 150, language: 'haskell', name: 'foo', uids: [user2.uid], organization: 'test', course: course.slug, passing_criterion_type: 'none'} }
-          before { Exam.import_from_resource_h! exam_json2 }
-
-          it { expect(Exam.count).to eq 1 }
-          it { expect(Usage.where(organization: Organization.current, item: guide).count).to eq 1 }
-          it { expect { Exam.find_by(classroom_id: '1').validate_accessible_for! user }.to raise_error(Mumuki::Domain::ForbiddenError) }
-          it { expect { Exam.find_by(classroom_id: '1').validate_accessible_for! user2 }.to_not raise_error }
-          it { expect { Exam.last.passing_criterion }.to_not raise_error }
-
-        end
-      end
-
-      context 'real_end_time' do
-        let(:user) { create(:user, uid: 'auth0|1') }
-        let(:guide) { create(:guide) }
-        let(:exam_json) { {eid: '1', slug: guide.slug, start_time: 5.minutes.ago, end_time: 10.minutes.since, duration: duration, language: 'haskell', name: 'foo', uids: [user.uid], organization: 'test', course: course.slug, passing_criterion_type: 'none'} }
-        let(:exam) { Exam.import_from_resource_h! exam_json }
-        before { exam.start! user }
-
-        context 'with duration' do
-          let(:duration) { 150 }
-          it { expect(exam.real_end_time user).to eq(exam.end_time) }
-          it { expect(exam.started? user).to be_truthy }
-        end
-
-        context 'with short duration' do
-          let(:duration) { 3 }
-          it { expect(exam.real_end_time user).to eq(exam.started_at(user) + 3.minutes) }
-          it { expect(exam.started? user).to be_truthy }
-        end
-
-        context 'no duration' do
-          let(:duration) { nil }
-          it { expect(exam.real_end_time user).to eq(exam.end_time) }
-          it { expect(exam.started? user).to be_truthy }
-        end
-      end
-
-      context 'update exam does not change user started_at' do
-        let(:user) { create(:user, uid: 'auth0|1') }
-        let(:guide) { create(:guide) }
-        let(:exam_json) { {eid: '1', slug: guide.slug, start_time: 5.minutes.ago, end_time: 10.minutes.since, duration: 150, language: 'haskell', name: 'foo', uids: [user.uid], organization: 'test', course: course.slug, passing_criterion_type: 'none'} }
-        let(:exam) { Exam.import_from_resource_h! exam_json }
-        before { exam.start! user }
-        before { Exam.import_from_resource_h! exam_json.merge(organization: 'test') }
-
-        it { expect(exam.started?(user)).to be true }
-
-      end
-
-      context 'create exam with non existing user' do
-        let(:guide) { create(:guide) }
-        let(:exam_json) { {eid: '1', slug: guide.slug, start_time: 5.minutes.ago, end_time: 10.minutes.since, duration: 150, language: 'haskell', name: 'foo', uids: [user.uid], organization: 'test', course: course.slug, passing_criterion_type: 'none'} }
-        let(:exam) { Exam.import_from_resource_h! exam_json }
-
-        it { expect { Exam.import_from_resource_h! exam_json.merge(organization: 'test') }.not_to raise_error }
-
-      end
-
-      context '.passing_criterion' do
-        let(:criterion_value) { 75 }
-        let(:criterion_type) { 'none' }
-        let(:exam) { create(:exam, passing_criterion_type: criterion_type, passing_criterion_value: criterion_value) }
-        context 'passing_criterion_type' do
-          context 'percentage criterion' do
-            let(:criterion_type) { 'percentage' }
-            it { expect(exam.passing_criterion).to be_an_instance_of Exam::PassingCriterion::Percentage }
-          end
-          context 'passed_exercises criterion' do
-            let(:criterion_type) { 'passed_exercises' }
-            it { expect(exam.passing_criterion).to be_an_instance_of Exam::PassingCriterion::PassedExercises }
-          end
-          context 'none criterion' do
-            let(:criterion_type) { 'none' }
-            it { expect(exam.passing_criterion).to be_an_instance_of Exam::PassingCriterion::None }
-          end
-          context 'nil criterion' do
-            let(:criterion_type) { nil }
-            it { expect(exam.passing_criterion).to be_an_instance_of Exam::PassingCriterion::None }
-          end
-          context 'invalid criterion' do
-            let(:criterion_type) { 'unsupported' }
-            it { expect { exam.passing_criterion }.to raise_error ArgumentError }
-          end
-        end
-        context 'passing_criterion_value' do
-          context 'with invalid percentage' do
-            let(:criterion_type) { 'percentage'}
-            let(:criterion_value) { 101 }
-            it { expect { exam.passing_criterion }.to raise_error("Invalid criterion value #{criterion_value} for #{criterion_type}") }
-          end
-          context 'with invalid passed_exercises' do
-            let(:criterion_type) { 'passed_exercises'}
-            let(:criterion_value) { -1 }
-            it { expect { exam.passing_criterion }.to raise_error("Invalid criterion value #{criterion_value} for #{criterion_type}") }
-          end
-        end
-      end
-
-
-      context 'unauthorized user does not start' do
-        let(:exam) { create(:exam) }
-        it { expect { exam.start! user }.to raise_error Mumuki::Domain::ForbiddenError }
-      end
-
-      context 'teacher does not start exams' do
-        let(:teacher) { create(:user, uid: 'auth0|1') }
-        let(:guide) { create(:guide) }
-        let(:exam_json) { {eid: '1', slug: guide.slug, start_time: 5.minutes.ago, end_time: 10.minutes.since, duration: 150, language: 'haskell', name: 'foo', uids: [], organization: 'test', course: course.slug, passing_criterion_type: 'none'} }
-        let(:exam) { Exam.import_from_resource_h! exam_json }
-
-        context 'exam_authorization do not receive start method' do
-          before { expect(teacher).to receive(:teacher_here?).and_return(true) }
-          before { expect_any_instance_of(ExamAuthorization).to_not receive(:start!) }
-          it { expect { exam.start!(teacher) }.to_not raise_error }
-
-        end
-
-        context 'exam is not started by a teacher' do
-          it { expect(exam.started?(teacher)).to be_falsey }
-        end
-
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-7082a83493eb/spec/models/exercise_spec.rb

@@ -1,589 +0,0 @@
-require 'spec_helper'
-
-describe Exercise, organization_workspace: :test do
-  let(:exercise) { create(:exercise) }
-  let(:user) { create(:user, first_name: 'Orlo') }
-
-  describe("schema fields are in sync") do
-    let(:resource_h_fields) { Exercise.new(guide: Guide.new, language: Language.new).to_expanded_resource_h.keys }
-    let(:schema_fields) { Mumuki::Domain::Store::Github::ExerciseSchema.fields.map(&:reverse_name) }
-
-    it { expect(resource_h_fields).to contain_exactly(*schema_fields) }
-  end
-
-  describe '#choice_values' do
-    context 'when choices are in 6.0 format' do
-      let(:choices) { [{value: '1492', checked: false}, {value: '1453', checked: true}, {value: '1773', checked: false}] }
-      let(:exercise) { build(:exercise, description: 'when did byzantine empire fall?', choices: choices) }
-
-      it { expect(exercise.choices).to eq choices }
-      it { expect(exercise[:choice_values]).to be_blank }
-      it { expect(exercise.choice_values).to eq %w(1492 1453 1773) }
-      it { expect(exercise.choice_index_for '1492').to eq 0 }
-      it { expect(exercise.choice_index_for '1773').to eq 2 }
-    end
-  end
-
-  describe 'transparent navigation api' do
-    let(:guide) { create(:guide, slug: 'foo/bar') }
-    let!(:exercise) { create(:exercise, guide: guide, bibliotheca_id: 4) }
-    let(:params) { { organization: 'foo', repository: 'bar', bibliotheca_id: 4 } }
-
-    it { expect(exercise.transparent_id).to eq 'foo/bar/4' }
-    it { expect(exercise.transparent_params).to eq params }
-    it { expect(Exercise.find_transparently!(params)).to eq exercise }
-  end
-
-  describe 'locate!' do
-    let(:guide) { create(:guide, slug: 'foo/bar') }
-    let(:exercise) { create(:exercise, guide: guide, bibliotheca_id: 4) }
-
-    it { expect(Exercise.locate!([guide.slug, exercise.bibliotheca_id])).to eq exercise }
-  end
-
-  describe '#new_solution' do
-    context 'when there is default content' do
-      let(:exercise) { create(:exercise, default_content: 'foo') }
-
-      it { expect(exercise.new_solution.content).to eq 'foo' }
-    end
-
-    context 'when there is no default content' do
-      let(:exercise) { create(:exercise) }
-
-      it { expect(exercise.new_solution.content).to be_blank }
-    end
-  end
-
-  describe '#next_for' do
-    context 'when exercise has no guide' do
-      it { expect(exercise.next_for(user)).to be nil }
-    end
-    context 'when exercise belong to a guide with a single exercise' do
-      let(:exercise_with_guide) { create(:exercise, guide: guide) }
-      let(:guide) { create(:guide) }
-
-      it { expect(exercise_with_guide.next_for(user)).to be nil }
-    end
-    context 'when exercise belongs to a guide with two exercises' do
-      let!(:exercise_with_guide) { create(:exercise, guide: guide, number: 2) }
-      let!(:alternative_exercise) { create(:exercise, guide: guide, number: 3) }
-      let!(:guide) { create(:guide) }
-
-      it { expect(exercise_with_guide.next_for(user)).to eq alternative_exercise }
-    end
-
-    context 'when exercise belongs to a guide with two exercises and alternative exercise has been solved',
-            organization_workspace: :test do
-      let(:exercise_with_guide) { create(:exercise, guide: guide) }
-      let!(:alternative_exercise) { create(:exercise, guide: guide) }
-      let(:guide) { create(:indexed_guide) }
-
-      before { alternative_exercise.submit_solution!(user, content: 'foo').passed! }
-
-      it { expect(exercise_with_guide.next_for(user)).to be nil }
-    end
-
-    context 'when exercise belongs to a guide with two exercises and alternative exercise has been submitted but not solved',
-            organization_workspace: :test do
-      let!(:exercise_with_guide) { create(:exercise, guide: guide, number: 2) }
-      let!(:alternative_exercise) { create(:exercise, guide: guide, number: 3) }
-      let(:guide) { create(:guide) }
-
-      before { alternative_exercise.submit_solution!(user, content: 'foo') }
-
-      it { expect(guide.pending_exercises(user)).to_not eq [] }
-      it { expect(guide.next_exercise(user)).to_not be nil }
-      it { expect(guide.pending_exercises(user)).to include(alternative_exercise) }
-      it { expect(exercise_with_guide.next_for(user)).to eq alternative_exercise }
-      it { expect(guide.exercises).to_not eq [] }
-      it { expect(exercise_with_guide.guide).to eq guide }
-      it { expect(guide.pending_exercises(user)).to include(exercise_with_guide) }
-    end
-  end
-
-  describe '#extra' do
-    context 'when exercise has no extra code' do
-      it { expect(exercise.extra).to eq '' }
-    end
-
-    context 'when exercise has extra code and has no guide' do
-      let!(:exercise_with_extra) { create(:exercise, extra: 'exercise extra code') }
-
-      it { expect(exercise_with_extra.extra).to eq "exercise extra code\n" }
-    end
-
-    context 'when exercise has extra code and ends with new line and has no guide' do
-      let!(:exercise_with_extra) { create(:exercise, extra: "exercise extra code\n") }
-
-      it { expect(exercise_with_extra.extra).to eq "exercise extra code\n" }
-    end
-
-    context 'when exercise has extra code and belongs to a guide with no extra code' do
-      let!(:exercise_with_extra) { create(:exercise, guide: guide, extra: 'exercise extra code') }
-      let!(:guide) { create(:guide) }
-
-      it { expect(exercise_with_extra.extra).to eq "exercise extra code\n" }
-    end
-
-    context 'when exercise has extra code with trailing whitespaces
-             and belongs to a guide with no extra code' do
-      let!(:exercise_with_extra) { create(:exercise, guide: guide, extra: "\nexercise extra code \n") }
-      let!(:guide) { create(:guide) }
-
-      it { expect(exercise_with_extra.extra).to eq "exercise extra code\n" }
-    end
-
-    context 'when exercise has extra code and belongs to a guide with extra code' do
-      let!(:exercise_with_extra) { create(:exercise, guide: guide, extra: 'exercise extra code') }
-      let!(:guide) { create(:guide, extra: 'guide extra code') }
-
-      it { expect(exercise_with_extra.extra).to eq "guide extra code\nexercise extra code\n" }
-      it { expect(exercise_with_extra[:extra]).to eq 'exercise extra code' }
-    end
-  end
-
-  describe '#extra_preview', organization_workspace: :test do
-    let(:haskell) { create(:haskell) }
-    let(:guide) { create(:guide,
-                         extra: 'f x = 1',
-                         language: haskell,
-                         exercises: [create(:exercise,
-                                            extra: 'g y = y + 3',
-                                            language: haskell)]) }
-    let(:exercise) { guide.exercises.first }
-
-    it { expect(exercise.assignment_for(user).extra_preview).to eq "```haskell\nf x = 1\ng y = y + 3\n```" }
-  end
-
-  describe '#submit_solution!', organization_workspace: :test do
-    let(:test_organization) { Organization.current }
-    let(:another_organization) { create(:public_organization) }
-
-    context 'when user does no submission' do
-      it 'should not find a submission' do
-        expect(exercise.find_assignment_for(user, test_organization)).to be_blank
-      end
-    end
-
-    context 'when user does a submission in an organization' do
-      before { exercise.submit_solution!(user) }
-
-      it 'should find a submission for that user and organization' do
-        expect(exercise.find_assignment_for(user, test_organization)).to be_present
-      end
-    end
-  end
-
-  describe '#destroy' do
-    context 'when there are no submissions' do
-      it { exercise.destroy! }
-    end
-
-    context 'when there are submissions', organization_workspace: :test do
-      let!(:assignment) { create(:assignment, exercise: exercise) }
-      before { exercise.destroy! }
-      it { expect { Assignment.find(assignment.id) }.to raise_error(ActiveRecord::RecordNotFound) }
-    end
-
-  end
-
-  describe '#previous_solution_for', organization_workspace: :test do
-    context 'when user has a single submission for the exercise' do
-      let!(:assignment) { exercise.submit_solution!(user, content: 'foo') }
-
-      it { expect(assignment.current_content).to eq assignment.solution }
-    end
-
-    context 'when user has no submissions for the exercise' do
-      it { expect(exercise.assignment_for(user).current_content).to eq '' }
-    end
-
-    context 'when using an interpolation' do
-      let!(:chapter) {
-        create(:chapter, lessons: [
-          create(:lesson, exercises: [
-            first_exercise,
-            second_exercise,
-            previous_exercise,
-            exercise
-          ])]) }
-
-      let(:first_exercise) { create(:exercise) }
-      let(:second_exercise) { create(:exercise) }
-      let(:previous_exercise) { create(:exercise) }
-
-      before { reindex_current_organization! }
-
-      context 'when interpolation is in default_content' do
-        let(:assignment) { exercise.assignment_for(user) }
-
-        describe 'right previous content' do
-          let(:exercise) { create(:exercise, default_content: interpolation) }
-
-          context 'using previousContent' do
-            let(:interpolation) { '/*...previousContent...*/' }
-
-            context 'has previous submission' do
-              before { previous_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.current_content).to eq 'foobar' }
-            end
-
-            context 'does not have previous submission' do
-              it { expect(assignment.current_content).to eq '' }
-            end
-          end
-          context 'using previousSolution' do
-            let(:interpolation) { '/*...previousSolution...*/' }
-
-            context 'has previous submission' do
-              before { previous_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.current_content).to eq 'foobar' }
-            end
-
-            context 'does not have previous submission' do
-              it { expect(assignment.current_content).to eq '' }
-            end
-          end
-        end
-
-        describe 'indexed previous content' do
-          context '-2 index' do
-            let(:exercise) { create(:exercise, default_content: '/*...solution[-2]...*/') }
-
-            context 'has previous submission' do
-              before { second_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.current_content).to eq 'foobar' }
-            end
-          end
-          context '-1 index' do
-            let(:exercise) { create(:exercise, default_content: '/*...solution[-1]...*/') }
-
-            context 'has previous submission' do
-              before { previous_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.current_content).to eq 'foobar' }
-            end
-
-            context 'does not have previous submission' do
-              it { expect(assignment.current_content).to eq '' }
-            end
-          end
-          context '1 index' do
-            let(:exercise) { create(:exercise, default_content: '/*...solution[1]...*/') }
-
-            context 'has previous submission' do
-              before { first_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.current_content).to eq 'foobar' }
-            end
-          end
-          context '2 index' do
-            let(:exercise) { create(:exercise, default_content: '/*...solution[2]...*/') }
-
-            context 'has previous submission' do
-              before { second_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.current_content).to eq 'foobar' }
-            end
-          end
-          context '3 index' do
-            let(:exercise) { create(:exercise, default_content: '/*...solution[3]...*/') }
-
-            context 'has previous submission' do
-              before { previous_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.current_content).to eq 'foobar' }
-            end
-          end
-        end
-      end
-      context 'when interpolation is in test' do
-        let(:assignment) { exercise.assignment_for(user) }
-
-        context 'using user_first_name'  do
-          let(:exercise) { create(:exercise, test: "<div>Hola #{interpolation}</div>") }
-          let(:interpolation) { '/*...user_first_name...*/' }
-
-          it { expect(assignment.test).to eq "<div>Hola Orlo</div>" }
-        end
-
-        context 'and test is nil'  do
-          let(:exercise) { create(:exercise, test: nil, expectations: [{binding: "program", inspection: 'Uses:foo'}]) }
-
-          it { expect(assignment.test).to eq nil }
-        end
-      end
-      context 'when interpolation is in extra' do
-        let(:assignment) { exercise.assignment_for(user) }
-
-        describe 'right previous content' do
-          let(:exercise) { create(:exercise, extra: interpolation) }
-
-          context 'using previousContent' do
-            let(:interpolation) { '/*...previousContent...*/' }
-
-            context 'has previous submission' do
-              before { previous_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.extra).to eq "foobar\n" }
-            end
-
-            context 'does not have previous submission' do
-              it { expect(assignment.extra).to eq "\n" }
-            end
-          end
-          context 'using previousSolution' do
-            let(:interpolation) { '/*...previousSolution...*/' }
-
-            context 'has previous submission' do
-              before { previous_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.extra).to eq "foobar\n" }
-            end
-
-            context 'does not have previous submission' do
-              it { expect(assignment.extra).to eq "\n" }
-            end
-          end
-        end
-
-        describe 'indexed previous content' do
-          context '-2 index' do
-            let(:exercise) { create(:exercise, extra: '/*...solution[-2]...*/') }
-
-            context 'has previous submission' do
-              before { second_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.extra).to eq "foobar\n" }
-            end
-          end
-          context '-1 index' do
-            let(:exercise) { create(:exercise, extra: '/*...solution[-1]...*/') }
-
-            context 'has previous submission' do
-              before { previous_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.extra).to eq "foobar\n" }
-            end
-
-            context 'does not have previous submission' do
-              it { expect(assignment.extra).to eq "\n" }
-            end
-          end
-          context '1 index' do
-            let(:exercise) { create(:exercise, extra: '/*...solution[1]...*/') }
-
-            context 'has previous submission' do
-              before { first_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.extra).to eq "foobar\n" }
-            end
-          end
-          context '2 index' do
-            let(:exercise) { create(:exercise, extra: '/*...solution[2]...*/') }
-
-            context 'has previous submission' do
-              before { second_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.extra).to eq "foobar\n" }
-            end
-          end
-          context '3 index' do
-            let(:exercise) { create(:exercise, extra: '/*...solution[3]...*/') }
-
-            context 'has previous submission' do
-              before { previous_exercise.submit_solution!(user, content: 'foobar') }
-              it { expect(assignment.extra).to eq "foobar\n" }
-            end
-          end
-        end
-      end
-    end
-
-    context 'when user has multiple submission for the exercise' do
-      before { exercise.submit_solution!(user, content: 'foo') }
-      let!(:assignment) { exercise.submit_solution!(user, content: 'bar') }
-
-      it { expect(assignment.current_content).to eq assignment.solution }
-    end
-
-    context 'when user has no solution and exercise has default content' do
-      let(:exercise) { create(:exercise, default_content: '#write here...') }
-      let(:assignment) { exercise.assignment_for user }
-
-      it { expect(assignment.current_content).to eq '#write here...' }
-    end
-  end
-
-  describe '#guide_done_for?', organization_workspace: :test do
-    context 'when it does not belong to a guide' do
-      it { expect(exercise.guide_done_for?(user)).to be false }
-    end
-
-    context 'when it belongs to an unfinished guide' do
-      let!(:guide) { create(:indexed_guide) }
-      let!(:exercise_unfinished) { create(:exercise, guide: guide) }
-      let!(:exercise_finished) { create(:exercise, guide: guide) }
-
-      before do
-        exercise_finished.submit_solution!(user, content: 'foo').passed!
-      end
-
-      it { expect(exercise_finished.guide_done_for?(user)).to be false }
-    end
-
-    context 'when it belongs to a finished guide' do
-      let!(:guide) { create(:indexed_guide) }
-      let!(:exercise_finished) { create(:exercise, guide: guide) }
-      let!(:exercise_finished2) { create(:exercise, guide: guide) }
-
-      before do
-        exercise_finished.submit_solution!(user, content: 'foo').passed!
-        exercise_finished2.submit_solution!(user, content: 'foo').passed!
-      end
-
-      it { expect(exercise_finished.guide_done_for?(user)).to be true }
-    end
-  end
-
-  describe '#language' do
-    let(:guide) { create(:guide) }
-    let(:exercise_with_guide) { create(:exercise, guide: guide, language: guide.language) }
-    let(:other_language) { create(:language) }
-
-    context 'when has no guide' do
-      it { expect(exercise.valid?).to be true }
-    end
-
-    context 'when has guide and is consistent' do
-      it { expect(exercise_with_guide.valid?).to be true }
-    end
-  end
-
-  describe '#friendly_name', organization_workspace: :test do
-    it { expect(Exercise.find(exercise.friendly_name)).to eq exercise }
-    it { expect(Problem.find(exercise.friendly_name)).to eq exercise }
-  end
-
-  describe 'messages_path_for', organization_workspace: :test do
-    let(:haskell) { create(:haskell) }
-    let(:problem) { create(:problem, bibliotheca_id: 32, guide: guide, language: haskell) }
-    let(:guide) { create(:guide, slug: 'mumuki/myguide') }
-
-    context 'user with email uid' do
-      let(:student) { create(:user, uid: 'foo@bar.com') }
-
-      it { expect(problem.messages_path_for(student))
-             .to eq 'api/guides/mumuki/myguide/32/student/foo@bar.com/messages?language=haskell' }
-      it { expect(problem.messages_url_for(student))
-             .to eq 'http://test.classroom-api.localmumuki.io/api/guides/mumuki/myguide/32/student/foo@bar.com/messages?language=haskell' }
-    end
-
-    context 'user with twitter uid' do
-      let(:student) { create(:user, uid: 'twitter|12134342') }
-
-      it { expect(problem.messages_url_for(student))
-             .to eq 'http://test.classroom-api.localmumuki.io/api/guides/mumuki/myguide/32/student/twitter%7C12134342/messages?language=haskell' }
-    end
-  end
-
-  describe '#splitted_description' do
-    let(:exercise) { create(:exercise, description: "**Foo**\n\n> _Bar_") }
-    it { expect(exercise.description_context).to eq "<p><strong>Foo</strong></p>\n" }
-    it { expect(exercise.description_task).to eq "<p><em>Bar</em></p>\n" }
-  end
-
-  describe '#validate!' do
-    context 'non-empty, valid randomizations' do
-      let(:exercise) { build(:exercise,
-                            randomizations: {
-                              some_word: { type: :one_of, value: %w('some' 'word') },
-                              some_number: { type: :range, value: [1, 10] } }) }
-      it { expect { exercise.validate! }.not_to raise_error }
-    end
-
-    context 'empty inspections' do
-      let(:exercise) { build(:exercise, expectations: [{ "binding" => "program", "inspection" => "" }]) }
-      it { expect { exercise.validate! }.to raise_error(/expectations format is invalid/i) }
-    end
-
-    context 'invalid assistance_rules' do
-      let(:exercise) { build(:exercise, assistance_rules: [{ when: 'content_empty', then: ['asd'] }]) }
-      it { expect { exercise.validate! }.to raise_error(/assistance rules format is invalid/i) }
-    end
-
-    context 'invalid randomizations' do
-      let(:exercise) { build(:exercise, randomizations: { type: :range, value: [1] }) }
-      it { expect { exercise.validate! }.to raise_error(/randomizations format is invalid/i) }
-    end
-  end
-
-  describe '#files_for' do
-    before { create(:language, extension: 'js', highlight_mode: 'javascript') }
-    let(:current_content) { "/*<index.html#*/a html content/*#index.html>*/\n/*<a_file.js#*/a js content/*#a_file.js>*/" }
-    let(:assignment) { build(:assignment, exercise: exercise, solution: current_content) }
-    let(:files) { exercise.files_for(current_content) }
-
-    it { expect(files.count).to eq 2 }
-    it { expect(files[0]).to have_attributes(name: 'index.html', content: 'a html content') }
-    it { expect(files[0].highlight_mode).to eq 'html' }
-    it { expect(files[1]).to have_attributes(name: 'a_file.js', content: 'a js content') }
-    it { expect(files[1].highlight_mode).to eq 'javascript' }
-    it { expect(files.to_json).to eq assignment.files.to_json }
-  end
-
-  describe 'limited? && results_hidden?' do
-    let(:choice) { create(:multiple_choice) }
-    let(:problem) { create(:problem) }
-    let(:guide) { create(:guide, exercises: [choice, problem]) }
-
-    context 'in regular guide' do
-      let!(:chapter) { create(:chapter, lessons: [create(:lesson, guide: guide)]) }
-      before { reindex_current_organization! }
-
-      it { expect(choice.limited?).to eq false }
-      it { expect(problem.limited?).to eq false }
-      it { expect(choice.results_hidden?).to eq false }
-      it { expect(problem.results_hidden?).to eq false }
-    end
-
-    context 'in choice capped exam' do
-      let!(:exam) {create(:exam, max_choice_submissions: 2, guide: guide)}
-      it { expect(choice.limited?).to eq true }
-      it { expect(problem.limited?).to eq false }
-      it { expect(choice.results_hidden?).to eq false }
-      it { expect(problem.results_hidden?).to eq false }
-    end
-
-    context 'in problem capped exam' do
-      let!(:exam) {create(:exam, max_problem_submissions: 2, guide: guide)}
-      it { expect(choice.limited?).to eq false }
-      it { expect(problem.limited?).to eq true }
-      it { expect(choice.results_hidden?).to eq false }
-      it { expect(problem.results_hidden?).to eq false }
-    end
-
-    context 'in problem capped exam with results hidden for choice' do
-      let!(:exam) {create(:exam, max_problem_submissions: 2, results_hidden_for_choices: true, guide: guide)}
-      it { expect(choice.limited?).to eq false }
-      it { expect(problem.limited?).to eq true }
-      it { expect(choice.results_hidden?).to eq true }
-      it { expect(problem.results_hidden?).to eq false }
-    end
-
-    context 'in choice capped exam with results hidden for choice' do
-      let!(:exam) {create(:exam, max_choice_submissions: 2, results_hidden_for_choices: true, guide: guide)}
-      it { expect(choice.limited?).to eq false }
-      it { expect(problem.limited?).to eq false }
-      it { expect(choice.results_hidden?).to eq true }
-      it { expect(problem.results_hidden?).to eq false }
-    end
-
-    context 'in non-capped exam' do
-      let!(:exam) {create(:exam, guide: guide)}
-      it { expect(choice.limited?).to eq false }
-      it { expect(problem.limited?).to eq false }
-      it { expect(choice.results_hidden?).to eq false }
-      it { expect(problem.results_hidden?).to eq false }
-    end
-
-    context 'in non-capped exam with results hidden for choice' do
-      let!(:exam) {create(:exam, results_hidden_for_choices: true, guide: guide)}
-      it { expect(choice.limited?).to eq false }
-      it { expect(problem.limited?).to eq false }
-      it { expect(choice.results_hidden?).to eq true }
-      it { expect(problem.results_hidden?).to eq false }
-    end
-  end
-end