mumuki-laboratory 7.6.2 → 7.7.0

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

@@ -0,0 +1,36 @@
+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-cb7a9018bb94/spec/models/exam_spec.rb

@@ -0,0 +1,205 @@
+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-cb7a9018bb94/spec/models/exercise_spec.rb

@@ -0,0 +1,589 @@
+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