mumuki-laboratory 7.5.1 → 7.7.0

data/vendor/bundle/ruby/{2.3.0/bundler/gems/mumuki-domain-a059418e5fd8 → 2.6.0/bundler/gems/mumuki-domain-cb7a9018bb94}/spec/models/exam_spec.rb

@@ -3,19 +3,22 @@ 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'} }
+    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'} }
+      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
@@ -24,7 +27,7 @@ describe Exam, organization_workspace: :test do
 
   describe '#validate_accessible_for!' do
     context 'not enabled' do
-      let(:exam) { create(:exam, start_time: 5.minutes.since, end_time: 10.minutes.since) }
+      let(:exam) { create(:exam, start_time: 5.minutes.since, end_time: 10.minutes.since, course: course) }
 
       it { expect(exam.enabled?).to be false }
 
@@ -38,7 +41,7 @@ describe Exam, organization_workspace: :test do
     end
 
     context 'enabled' do
-      let(:exam) { create(:exam, start_time: 5.minutes.ago, end_time: 10.minutes.since) }
+      let(:exam) { create(:exam, start_time: 5.minutes.ago, end_time: 10.minutes.since, course: course) }
 
       it { expect(exam.enabled?).to be true }
 
@@ -58,7 +61,7 @@ describe Exam, organization_workspace: :test do
         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'} }
+        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
@@ -74,20 +77,22 @@ describe Exam, organization_workspace: :test do
         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'} }
+          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'} }
+        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 }
 
@@ -113,7 +118,7 @@ describe Exam, organization_workspace: :test do
       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'} }
+        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') }
@@ -124,13 +129,54 @@ describe Exam, organization_workspace: :test do
 
       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'} }
+        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 }
@@ -139,7 +185,7 @@ describe Exam, organization_workspace: :test do
       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'} }
+        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

data/vendor/bundle/ruby/{2.3.0/bundler/gems/mumuki-domain-a059418e5fd8 → 2.6.0/bundler/gems/mumuki-domain-cb7a9018bb94}/spec/models/invitation_spec.rb

@@ -12,13 +12,14 @@ describe Invitation, organization_workspace: :test do
   end
 
   describe '#unexpired' do
-    let(:invitation) { create(:invitation, expiration_date: expiration, course: course) }
+    let(:invitation) { create(:invitation, expiration_date: 5.minutes.since, course: course) }
     context 'when expired' do
-      let(:expiration) { 5.minutes.ago }
-      it { expect { invitation.unexpired }.to raise_error Mumuki::Domain::GoneError }
+      it do
+        invitation.update! expiration_date: 5.minutes.ago
+        expect { invitation.reload.unexpired }.to raise_error Mumuki::Domain::GoneError
+      end
     end
     context 'when not expired' do
-      let(:expiration) { 5.minutes.since }
       it { expect(invitation.unexpired).to eq invitation }
     end
   end

data/vendor/bundle/ruby/{2.3.0/bundler/gems/mumuki-domain-a059418e5fd8 → 2.6.0/bundler/gems/mumuki-domain-cb7a9018bb94}/spec/models/organization_spec.rb

@@ -47,7 +47,7 @@ describe Organization, organization_workspace: :test do
       end
 
       context 'when user meets minimal permissions' do
-        before { user.make_student_of! organization.slug }
+        before { user.make_student_of! organization }
         it { expect(organization.ask_for_help_enabled? user).to be true }
         it { expect(organization.ask_for_help_enabled?).to be true }
       end
@@ -157,8 +157,40 @@ describe Organization, organization_workspace: :test do
       it { expect(organization.has_login_method? 'github').to be true }
       it { expect(organization.has_login_method? 'google').to be false }
     end
+
+    context 'is invalid when activity range is not valid' do
+      let(:organization) { build :organization, in_preparation_until: 2.minutes.since, disabled_from: 1.minute.ago }
+      it { expect(organization.valid?).to be false }
+    end
+
+    context 'is valid when activity range is valid' do
+      let(:organization) { build :organization, in_preparation_until: 2.minutes.ago, disabled_from: 1.minute.since }
+      it { expect(organization.valid?).to be true }
+    end
+  end
+
+  describe '#validate_active!' do
+    context 'disabled?' do
+      let(:organization) { build(:organization, disabled_from: 5.minutes.ago) }
+      it { expect(organization.disabled?).to be true }
+      it { expect { organization.validate_active! }.to raise_error(Mumuki::Domain::DisabledOrganizationError) }
+    end
+
+    context 'in_preparation?' do
+      let(:organization) { build(:organization, in_preparation_until: 5.minutes.since) }
+      it { expect(organization.in_preparation?).to be true }
+      it { expect { organization.validate_active! }.to raise_error(Mumuki::Domain::UnpreparedOrganizationError) }
+    end
+
+    context 'active' do
+      let(:organization) { build(:organization, disabled_from: 5.minutes.since, in_preparation_until: 2.minutes.ago) }
+      it { expect(organization.in_preparation?).to be false }
+      it { expect(organization.disabled?).to be false }
+      it { expect { organization.validate_active! }.to_not raise_error }
+    end
   end
 
+
   describe 'in_path' do
     let(:organization) { create :public_organization, name: 'main' }
     let!(:other_organization) { create :public_organization, name: 'other' }

data/vendor/bundle/ruby/{2.3.0/bundler/gems/mumuki-domain-a059418e5fd8 → 2.6.0/bundler/gems/mumuki-domain-cb7a9018bb94}/spec/models/problem_spec.rb

@@ -82,4 +82,10 @@ describe Problem, organization_workspace: :test do
 
   end
 
+  describe 'layout' do
+    it { expect(Problem.new(layout: :input_bottom).layout).to be_like :input_bottom }
+    it { expect(Problem.new(layout: :input_primary).layout).to be_like :input_primary }
+    it { expect(Problem.new(layout: :input_kids).layout).to be_like :input_primary }
+    it { expect(Problem.new(layout: :input_kindergarten).layout).to be_like :input_kindergarten }
+  end
 end

data/vendor/bundle/ruby/{2.3.0/bundler/gems/mumuki-domain-a059418e5fd8 → 2.6.0/bundler/gems/mumuki-domain-cb7a9018bb94}/spec/models/solution_spec.rb

@@ -37,20 +37,75 @@ describe Mumuki::Domain::Submission::Solution, organization_workspace: :test do
   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) }
-    let(:assignment) { exercise.submit_solution! user }
+    before { expect_any_instance_of(Language).to receive(:run_tests!).with(bridge_request).and_return(bridge_response) }
+    let(:submission_attributes) { {} }
+    let(:assignment) { exercise.submit_solution! user, submission_attributes }
 
     context 'when results have no expectation' do
       let(:exercise) { create(:indexed_exercise) }
+      let(:bridge_request) do
+        {
+          content: nil,
+          custom_expectations: "\n",
+          expectations: [],
+          extra: "",
+          locale: "en",
+          settings: {},
+          test: "dont care"
+        }
+      end
       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 submissions has client result' do
+      let(:exercise) { create(:indexed_exercise) }
+      let(:bridge_request) do
+        {
+          content: 'x = 2',
+          custom_expectations: "\n",
+          expectations: [],
+          extra: "",
+          locale: "en",
+          settings: {},
+          test: "dont care",
+          client_result: {
+            status: :passed,
+            test_results: [{title: 'true is true', status: :passed, result: ''}]
+          }
+        }
+      end
+      let(:bridge_response) { {result: '0 failures', status: :passed} }
+      let(:submission_attributes) do
+        {
+          content: 'x = 2',
+          client_result: {
+            status: :passed,
+            test_results: [{title: 'true is true', status: :passed, result: ''}]
+          }
+        }
+      end
+
+      it { expect(assignment.status).to eq(:passed) }
+      it { expect(assignment.result).to include('0 failures') }
+    end
+
     context 'when results have standard expectations' do
       let(:exercise) {
         create(:indexed_exercise, expectations: [{binding: :foo, inspection: :HasComposition}]) }
+      let(:bridge_request) do
+        {
+          content: nil,
+          custom_expectations: "\n",
+          expectations: [{"binding"=>:foo, "inspection"=>:HasComposition}],
+          extra: "",
+          locale: "en",
+          settings: {},
+          test: "dont care"
+        }
+      end
       let(:bridge_response) { {
           result: '0 failures',
           status: :passed,
@@ -61,9 +116,19 @@ describe Mumuki::Domain::Submission::Solution, organization_workspace: :test do
       it { expect(assignment.expectation_results).to eq([{binding: 'foo', inspection: 'HasBinding', result: :passed}]) }
     end
 
-
     context 'when results have custom expectations' do
       let(:exercise) { create(:indexed_exercise, custom_expectations: 'expectation "foo uses composition": `foo` uses composition;') }
+      let(:bridge_request) do
+        {
+          content: nil,
+          custom_expectations: "expectation \"foo uses composition\": `foo` uses composition;\n",
+          expectations: [],
+          extra: "",
+          locale: "en",
+          settings: {},
+          test: "dont care"
+        }
+      end
       let(:bridge_response) { {
           result: '0 failures',
           status: :passed,

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Mumuki::Domain::Status do
+  describe 'discussion' do
+    it { expect(Mumuki::Domain::Status::Discussion::PendingReview.as_json).to eq 'pending_review' }
+  end
+
+  describe 'discussion' do
+    it { expect(Mumuki::Domain::Status::Submission::PassedWithWarnings.as_json).to eq 'passed_with_warnings' }
+  end
+end

data/vendor/bundle/ruby/{2.3.0/bundler/gems/mumuki-domain-a059418e5fd8 → 2.6.0/bundler/gems/mumuki-domain-cb7a9018bb94}/spec/models/user_spec.rb

@@ -146,6 +146,30 @@ describe User, organization_workspace: :test do
     end
   end
 
+  describe '#completed_containers_with_lookahead' do
+    let(:student) { create :user }
+
+    let(:organization) { Organization.current }
+
+    let(:exercise_1) { create(:exercise) }
+    let(:exercise_2) { create(:exercise) }
+
+    let(:lesson_1) { create :lesson, exercises: [exercise_1] }
+    let(:lesson_2) { create :lesson, exercises: [exercise_2] }
+
+    context 'lookahead 0' do
+      it { expect { student.completed_containers_with_lookahead([lesson_1, lesson_2], organization, lookahead: 0) }.to raise_error('invalid lookahead')  }
+    end
+
+    context 'no items completed' do
+      it { expect(student.completed_containers_with_lookahead([lesson_1, lesson_2], organization)).to eq [lesson_1] }
+    end
+
+    context 'no items with lookahead 2' do
+      it { expect(student.completed_containers_with_lookahead([lesson_1, lesson_2], organization, lookahead: 2)).to eq [lesson_1, lesson_2] }
+    end
+  end
+
   describe '#visit!' do
     let(:user) { build(:user) }
 
@@ -264,6 +288,37 @@ describe User, organization_workspace: :test do
     it { expect(student_in_exam.currently_in_exam?).to be true }
   end
 
+  describe '#name_initials' do
+    context 'with first_name and last_name' do
+      let(:user) { create(:user, first_name: 'John', last_name: 'Doe') }
+
+      it { expect(user.name_initials).to eq 'J D' }
+    end
+
+    context 'with just first_name' do
+      let(:user) { create(:user, first_name: 'John', last_name: nil) }
+
+      it { expect(user.name_initials).to eq 'J' }
+    end
+
+    context 'with just last_name' do
+      let(:user) { create(:user, first_name: nil, last_name: 'Doe') }
+
+      it { expect(user.name_initials).to eq 'D' }
+    end
+
+    context 'with no first_name or last_name' do
+      let(:user) { create(:user, first_name: nil, last_name: nil) }
+
+      it { expect(user.name_initials).to eq '' }
+    end
+
+    context 'with several names' do
+      let(:user) { create(:user, first_name: 'John George', last_name: 'Doe Foo') }
+
+      it { expect(user.name_initials).to eq 'J G D F' }
+    end
+  end
 
   describe 'disabling' do
     let(:user) { create(:user, first_name: 'John', last_name: 'Doe') }