mumuki-laboratory 7.6.2 → 7.7.0

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

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

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

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

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

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Mumuki::Domain::Submission::Solution, organization_workspace: :test do
+
+  let(:user) { create(:user) }
+
+  describe '#try_submit_solution!' do
+
+    context 'when on chapter' do
+      let(:problem) { create(:problem) }
+      let!(:chapter) {
+        create(:chapter, name: 'Functional Programming', lessons: [
+          create(:lesson, exercises: [problem])
+        ]) }
+
+      before { reindex_current_organization! }
+      let!(:result) { problem.try_submit_solution! user }
+
+      it { expect(result).to eq problem.find_assignment_for(user, Organization.current) }
+      it { expect(result.attempts_left).to eq nil }
+      it { expect(result.attempts_left?).to be true }
+    end
+
+    context 'when on exam' do
+      let(:problem) { create(:problem) }
+      let!(:exam) { create(:exam, max_problem_submissions: 10, exercises: [problem]) }
+
+      before { reindex_current_organization! }
+      let(:result) { problem.try_submit_solution! user }
+
+      it { expect(result).to eq problem.find_assignment_for(user, Organization.current) }
+      it { expect(result.attempts_left).to eq 9 }
+      it { expect(result.attempts_left?).to be true }
+    end
+  end
+
+  describe '#submit_solution!' do
+
+    before { expect_any_instance_of(Challenge).to receive(:automated_evaluation_class).and_return(Mumuki::Domain::Evaluation::Automated) }
+    before { expect_any_instance_of(Language).to receive(:run_tests!).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,
+          expectation_results: [binding: 'foo', inspection: 'HasBinding', result: :passed]} }
+
+      it { expect(assignment.status).to eq(:passed) }
+      it { expect(assignment.result).to include('0 failures') }
+      it { expect(assignment.expectation_results).to eq([{binding: 'foo', inspection: 'HasBinding', result: :passed}]) }
+    end
+
+    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,
+          expectation_results: [binding: '<<custom>>', inspection: 'foo uses composition', result: :passed]} }
+
+      it { expect(assignment.status).to eq(:passed) }
+      it { expect(assignment.result).to include('0 failures') }
+      it { expect(assignment.expectation_results).to eq([binding: '<<custom>>', inspection: 'foo uses composition', result: :passed]) }
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Stats do
+  context 'when someone has not started' do
+    let(:stats) { Stats.new(passed: 0, passed_with_warnings: 0, failed: 0, pending: 10, skipped: 0) }
+    it { expect(stats.submitted).to eq 0 }
+    it { expect(stats.done?).to be false }
+    it { expect(stats.started?).to be false }
+  end
+
+  context 'when someone has started but is not done' do
+    let(:stats) { Stats.new(passed: 3, passed_with_warnings: 2, failed: 1, pending: 3, skipped: 1) }
+    it { expect(stats.submitted).to eq 6 }
+    it { expect(stats.done?).to be false }
+    it { expect(stats.started?).to be true }
+  end
+
+  context 'when someone is done' do
+    let(:stats) { Stats.new(passed: 7, passed_with_warnings: 2, failed: 0, pending: 0, skipped: 1) }
+    it { expect(stats.submitted).to eq 9 }
+    it { expect(stats.done?).to be true }
+    it { expect(stats.started?).to be true }
+  end
+end

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.6.0/bundler/gems/mumuki-domain-cb7a9018bb94/spec/models/string_spec.rb

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

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

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Topic do
+  describe 'transparent navigation api' do
+    let!(:topic) { create(:topic, slug: 'foo/bar') }
+    let(:params) { { organization: 'foo', repository: 'bar' } }
+
+    it { expect(topic.transparent_id).to eq 'foo/bar' }
+    it { expect(topic.transparent_params).to eq params }
+    it { expect(Topic.find_transparently!(params)).to eq topic }
+  end
+
+  describe 'slug normalization' do
+    let(:topic) { create(:topic, slug: 'fLbUlGaReLlI/MuMUkI-saMPle-gUIde') }
+
+    it { expect(topic.slug).to eq('flbulgarelli/mumuki-sample-guide') }
+  end
+
+  describe '#import_from_resource_h!' do
+    let!(:haskell) { create(:haskell) }
+    let!(:gobstones) { create(:gobstones) }
+
+    let!(:lesson_1) { create(:lesson, name: 'l1') }
+    let(:guide_1) { lesson_1.guide }
+
+    let!(:lesson_2) { create(:lesson, name: 'l2') }
+
+    let!(:guide_2) { create(:guide, name: 'g2') }
+    let!(:guide_3) { create(:guide, name: 'g3') }
+
+    let(:topic_resource_h) do
+      {name: 'sample topic',
+       description: 'topic description',
+       slug: 'mumuki/mumuki-sample-topic',
+       locale: 'en',
+       lessons: [guide_2, guide_1, guide_3].map(&:slug)}
+    end
+
+    context 'when guide is empty' do
+      let(:topic) { create(:topic, lessons: [lesson_1, lesson_2]) }
+
+      before do
+        topic.import_from_resource_h!(topic_resource_h)
+      end
+
+      it { expect(topic.name).to eq 'sample topic' }
+      it { expect(topic.description).to eq 'topic description' }
+      it { expect(topic.locale).to eq 'en' }
+      it { expect(topic.lessons.count).to eq 3 }
+      it { expect(topic.lessons.first.guide).to eq guide_2 }
+      it { expect(topic.lessons.second).to eq lesson_1 }
+      it { expect(topic.lessons.third.guide).to eq guide_3 }
+      it { expect(Guide.count).to eq 4 }
+      it { expect(Lesson.count).to eq 3 }
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Usage do
+
+  let!(:fundamentals) { create(:topic) }
+  let!(:functional_programming) { create(:topic) }
+  let!(:oop) { create(:topic) }
+  let!(:logic_programming) { create(:topic) }
+
+  let!(:programming) { create(:book, chapters: [
+      build(:chapter, topic: fundamentals),
+      build(:chapter, topic: functional_programming),
+      build(:chapter, topic: oop),
+      build(:chapter, topic: logic_programming),
+  ]) }
+
+  let!(:paradigms) { create(:book, chapters: [
+      build(:chapter, topic: functional_programming),
+      build(:chapter, topic: logic_programming),
+      build(:chapter, topic: oop),
+  ]) }
+
+  let!(:central) { create(:organization, name: 'central', book: programming) }
+  let!(:pdep) { create(:organization, name: 'pdep', book: paradigms) }
+
+  shared_examples_for 'something that does not interfere with normal scopes' do
+    it 'does not affect all-scope' do
+      expect(Topic.all.count).to eq 4
+      expect(Chapter.all.count).to eq 7
+      expect(Book.all.count).to eq 2
+      expect(Organization.all.count).to eq 2
+    end
+  end
+
+  context 'on central' do
+    before { central.switch! }
+
+    it_behaves_like 'something that does not interfere with normal scopes'
+
+    it { expect(central.book).to eq programming }
+
+    it { expect(programming.chapters.count).to eq 4 }
+    it { expect(programming.chapters.map(&:topic)).to eq [fundamentals, functional_programming, oop, logic_programming] }
+
+    it 'usage_in_organization behaves properly' do
+      expect(fundamentals.usage_in_organization).to_not be_nil
+      expect(fundamentals.usage_in_organization.number).to eq 1
+
+      expect(functional_programming.usage_in_organization).to_not be_nil
+      expect(functional_programming.usage_in_organization).to be_a(Chapter)
+      expect(functional_programming.usage_in_organization.number).to eq 2
+      expect(oop.usage_in_organization.number).to eq 3
+      expect(logic_programming.usage_in_organization.number).to eq 4
+    end
+
+    it { expect(Usage.in_organization.count).to eq 5  }
+
+  end
+
+  context 'on pdep' do
+    before { pdep.switch! }
+
+    it_behaves_like 'something that does not interfere with normal scopes'
+
+    it { expect(pdep.book).to eq paradigms }
+
+    it { expect(paradigms.chapters.count).to eq 3 }
+    it { expect(paradigms.chapters.map(&:topic)).to eq [functional_programming, logic_programming, oop] }
+
+    it 'usage_in_organization behaves properly' do
+      expect(fundamentals.usage_in_organization).to be_nil
+
+      expect(functional_programming.usage_in_organization).to_not be_nil
+      expect(functional_programming.usage_in_organization).to be_a(Chapter)
+      expect(functional_programming.usage_in_organization.number).to eq 1
+      expect(logic_programming.usage_in_organization.number).to eq 2
+      expect(oop.usage_in_organization.number).to eq 3
+    end
+
+    it { expect(Usage.in_organization.count).to eq 4  }
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe User do
+  let(:user) { User.find_by(uid: 'foo@bar.com') }
+  let(:user_json) { {
+    uid: 'foo@bar.com',
+    first_name: 'Foo',
+    last_name: 'Bar',
+    permissions: {student: 'test/example'},
+    id: 1
+  } }
+
+  context 'when new user' do
+    before { User.import_from_resource_h! user_json }
+    it { expect(user.uid).to eq 'foo@bar.com' }
+    it { expect(user.name).to eq 'Foo Bar' }
+
+    context  'when user is created with no verified name' do
+      it { expect(user.verified_first_name).to be_nil }
+    end
+  end
+
+  context 'when user is created with verified names' do
+    let(:verified_user_json) { user_json.merge(verified_first_name: 'Baz', verified_last_name: 'Foobar') }
+    before { User.import_from_resource_h! verified_user_json }
+    it { expect(user.verified_first_name).to eq 'Baz' }
+    it { expect(user.verified_last_name).to eq 'Foobar' }
+  end
+
+  context 'when user exists' do
+    let(:new_json) { {
+      uid: 'foo@bar.com',
+      first_name: 'Foo',
+      last_name: 'Baz',
+      permissions: {student: 'test/example2'},
+      id: 1
+    } }
+    before { User.import_from_resource_h! user_json }
+    before { User.import_from_resource_h! new_json }
+    it { expect(user.name).to eq 'Foo Baz' }
+    it { expect(user.student? 'test/example2').to be true }
+    it { expect(user.student? 'test/example').to be false }
+  end
+end

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

@@ -0,0 +1,359 @@
+require 'spec_helper'
+
+describe User, organization_workspace: :test do
+
+  context 'can not have a null or empty uid' do
+    it { expect { User.create! uid: nil }.to raise_error ActiveRecord::RecordInvalid }
+    it { expect { User.create! uid: '' }.to raise_error ActiveRecord::RecordInvalid }
+  end
+
+  describe '#clear_progress!' do
+    let(:student) { create :user }
+    let(:more_clauses) { create(:exercise, name: 'More Clauses') }
+
+    before { more_clauses.submit_solution! student, content: 'foo(X) :- not(bar(X))' }
+
+    before { student.reload.clear_progress! }
+
+    it { expect(student.reload.assignments).to be_empty }
+    it { expect(student.never_submitted?).to be true }
+  end
+
+  describe '#transfer_progress_to!' do
+
+    let(:codeorga) { build :organization, name: 'code.orga' }
+    let(:prologschool) { build :organization, name: 'prologschool' }
+
+    let(:your_first_program) { build(:exercise, name: 'Your First Program') }
+    let(:more_clauses) { build(:exercise, name: 'More Clauses') }
+
+    let(:two_hours_ago) { 2.hours.ago }
+
+    context 'when final user has less information than original' do
+      let!(:submission) { your_first_program.submit_solution! original, content: 'adasdsadas' }
+
+      before { original.reload.transfer_progress_to! final }
+
+      let(:original) { create :user,
+                              permissions: {student: 'codeorga/*'},
+                              first_name: 'johnny',
+                              last_name: 'doe',
+                              social_id: 'auth0|123456',
+                              last_organization: codeorga }
+
+      let(:final) { create :user,
+                           permissions: Mumukit::Auth::Permissions.new,
+                           first_name: 'John',
+                           last_name: 'Doe',
+                           social_id: 'auth0|345678' }
+
+      it { expect(final.name).to eq 'John Doe' }
+      it { expect(final.social_id).to eq 'auth0|345678' }
+
+      it { expect(final.last_submission_date).to eq original.last_submission_date }
+      it { expect(final.last_organization).to eq codeorga }
+      it { expect(final.last_exercise).to eq your_first_program }
+
+      it { expect(final.permissions.as_json).to json_like({}) }
+
+      it { expect(submission.reload.submitter).to eq final }
+    end
+
+    context 'when final user has more information than original' do
+      before { more_clauses.submit_solution! final, content: 'adasdsadas' }
+      before { original.transfer_progress_to! final.reload }
+
+      let(:original) { create :user,
+                              permissions: Mumukit::Auth::Permissions.new,
+                              first_name: 'johnny',
+                              last_name: 'doe',
+                              social_id: 'auth0|123456' }
+      let(:final) { create :user,
+                           permissions: {student: 'prologschool/*'},
+                           first_name: 'John',
+                           last_name: 'Doe',
+                           social_id: 'auth0|345678',
+                           last_organization: prologschool }
+
+      it { expect(final.name).to eq 'John Doe' }
+      it { expect(final.social_id).to eq 'auth0|345678' }
+
+      it { expect(final.last_submission_date).to_not be nil }
+      it { expect(final.last_organization).to eq prologschool }
+      it { expect(final.last_exercise).to eq more_clauses }
+
+      it { expect(final.permissions.as_json).to json_like student: 'prologschool/*' }
+    end
+
+    context 'when both have information, but final is newer' do
+      before { original.transfer_progress_to! final }
+
+      let(:original) { create :user,
+                              permissions: {student: 'codeorga/*'},
+                              first_name: 'johnny',
+                              last_name: 'doe',
+                              social_id: 'auth0|123456',
+                              last_submission_date: 6.hours.ago,
+                              last_organization: codeorga,
+                              last_exercise: your_first_program }
+      let(:final) { create :user,
+                           permissions: {student: 'prologschool/*'},
+                           first_name: 'John',
+                           last_name: 'Doe',
+                           social_id: 'auth0|345678',
+                           last_submission_date: two_hours_ago,
+                           last_organization: prologschool,
+                           last_exercise: more_clauses }
+
+      it { expect(final.name).to eq 'John Doe' }
+      it { expect(final.social_id).to eq 'auth0|345678' }
+
+      it { expect(final.last_submission_date).to eq two_hours_ago }
+      it { expect(final.last_organization).to eq prologschool }
+      it { expect(final.last_exercise).to eq more_clauses }
+
+      it { expect(final.permissions.as_json).to json_like student: 'prologschool/*' }
+    end
+
+    context 'when both have information, but original is newer' do
+      before { original.transfer_progress_to! final }
+
+      let(:original) { create :user,
+                              permissions: {student: 'codeorga/*'},
+                              first_name: 'johnny',
+                              last_name: 'doe',
+                              social_id: 'auth0|123456',
+                              last_submission_date: two_hours_ago,
+                              last_organization: codeorga,
+                              last_exercise: your_first_program }
+      let(:final) { create :user,
+                           permissions: {student: 'prologschool/*'},
+                           first_name: 'John',
+                           last_name: 'Doe',
+                           social_id: 'auth0|345678',
+                           last_submission_date: 5.hours.ago,
+                           last_organization: prologschool,
+                           last_exercise: more_clauses }
+
+      it { expect(final.name).to eq 'John Doe' }
+      it { expect(final.social_id).to eq 'auth0|345678' }
+
+      it { expect(final.last_submission_date).to eq two_hours_ago }
+      it { expect(final.last_organization).to eq codeorga }
+      it { expect(final.last_exercise).to eq your_first_program }
+
+      it { expect(final.permissions.as_json).to json_like student: 'prologschool/*' }
+    end
+  end
+
+  describe '#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) }
+
+    before { user.visit! Organization.current }
+
+    it { expect(user.last_organization).to eq Organization.current }
+  end
+
+  describe 'roles' do
+    let(:other) { build(:organization, name: 'pdep') }
+    let(:user) { build :user, permissions: {student: 'pdep/k2001', teacher: 'test/all'} }
+
+    it { expect(user.student? 'test/all').to be true }
+    it { expect(user.student? 'pdep/k2001').to be true }
+
+    it { expect(user.teacher? 'test/all').to be true }
+    it { expect(user.teacher? 'pdep/k2001').to be false }
+  end
+
+  describe '#submissions_count' do
+    let!(:exercise_1) { build(:indexed_exercise) }
+    let!(:exercise_2) { build(:indexed_exercise) }
+    let!(:exercise_3) { build(:indexed_exercise) }
+
+    let(:user) { create(:user) }
+    context 'when there are no submissions' do
+      it { expect(user.reload.last_submission_date).to be nil }
+      it { expect(user.submitted_exercises_count).to eq 0 }
+      it { expect(user.solved_exercises_count).to eq 0 }
+      it { expect(user.submissions_count).to eq 0 }
+      it { expect(user.passed_submissions_count).to eq 0 }
+      it { expect(user.reload.last_exercise).to be_nil }
+      it { expect(user.reload.last_guide).to be_nil }
+    end
+
+    context 'when there are passed submissions' do
+      let!(:assignment_for) do
+        exercise_1.submit_solution!(user, content: '')
+        exercise_1.submit_solution!(user, content: '').passed!
+
+        exercise_2.submit_solution!(user, content: '').passed!
+
+        exercise_3.submit_solution!(user, content: '')
+        exercise_3.submit_solution!(user, content: '')
+      end
+
+      it { expect(user.reload.last_submission_date).to be > Assignment.last.created_at }
+      it { expect(user.submitted_exercises_count).to eq 3 }
+      it { expect(user.solved_exercises_count).to eq 2 }
+      it { expect(user.submissions_count).to eq 5 }
+      it { expect(user.passed_submissions_count).to eq 2 }
+      it { expect(user.reload.last_exercise).to eq exercise_3 }
+      it { expect(user.reload.last_guide).to eq exercise_3.guide }
+
+    end
+
+
+    context 'when there are only failed submissions' do
+      let!(:exercise_4) { build(:exercise) }
+
+      let!(:assignment_for) do
+        exercise_4.submit_solution!(user, content: '').failed!
+      end
+
+      it { expect(user.reload.last_exercise).to eq exercise_4 }
+      it { expect(user.reload.last_guide).to eq exercise_4.guide }
+    end
+  end
+
+
+  describe '.for_profile' do
+    let(:user) { create(:user, first_name: 'some name', last_name: 'some last name') }
+    let(:profile) { struct(uid: user.uid, first_name: nil, last_name: 'some other last name') }
+
+    before { User.for_profile profile }
+
+    it{ expect(User.find(user.id).first_name).to eq 'some name' }
+    it{ expect(User.find(user.id).last_name).to eq 'some other last name' }
+
+    describe 'notification' do
+      let(:user) { build(:user) }
+
+      context 'no changes' do
+        before { expect_any_instance_of(Mumukit::Nuntius::NotificationMode::Deaf).to_not receive(:notify_event!) }
+        it { User.for_profile profile }
+      end
+
+      context 'with changes' do
+        before { expect_any_instance_of(Mumukit::Nuntius::NotificationMode::Deaf).to receive(:notify_event!).exactly(1).times }
+        it { User.for_profile profile.to_h.merge(first_name: 'Mary').to_struct }
+        it { User.for_profile profile.to_h.merge(last_name: 'Doe').to_struct }
+      end
+
+    end
+  end
+
+  describe '#accept_invitation!' do
+    let(:student) { build :user }
+    let(:course) { create(:course, slug: 'test/an-awesome-2019-course') }
+    let(:invitation) { create :invitation, course: course  }
+    before { student.accept_invitation! invitation }
+    it { expect(student.student? 'test/an-awesome-2019-course').to be true }
+    it { expect(student.student? 'foo/bar').to be false }
+  end
+
+  describe '#currently_in_exam?' do
+    let(:student_not_in_exam) { build :user }
+    let(:student_in_exam) { build :user }
+    let(:exam) { create :exam }
+
+    before { exam.authorize! student_in_exam }
+    before { exam.authorize! student_not_in_exam }
+    before { exam.start! student_in_exam }
+
+    it { expect(student_not_in_exam.currently_in_exam?).to be false }
+    it { expect(student_in_exam.currently_in_exam?).to be true }
+  end
+
+  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') }
+
+    context 'enabled' do
+      it { expect { user.ensure_enabled! }.to_not raise_error }
+    end
+
+    context 'disabled' do
+      shared_context "disabled and buried user" do
+        it { expect(user).to be_disabled }
+        it { expect(user.accepts_reminders).to be false }
+        it { expect(user.name).to eq 'shibi' }
+        it { expect(user.email).to eq 'shibi@mumuki.org' }
+        it { expect(user.gender).to be nil }
+        it { expect(user.birthdate).to be nil }
+        it { expect(user.reload.name).to eq 'shibi' }
+        it { expect(user.disabled_at).to_not be nil }
+        it { expect { user.ensure_enabled! }.to raise_error(Mumuki::Domain::DisabledError) }
+      end
+
+      describe '#disable!' do
+        before { user.disable! }
+        it_behaves_like "disabled and buried user"
+      end
+
+      describe '#destroy!' do
+        before { user.destroy! }
+        it_behaves_like "disabled and buried user"
+      end
+
+      describe '#destroy' do
+        before { user.destroy }
+        it_behaves_like "disabled and buried user"
+      end
+    end
+  end
+end