mumuki-laboratory 7.0.10 → 7.0.11

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/lib/user_helpers_spec.rb

@@ -0,0 +1,140 @@
+require_relative '../spec_helper'
+
+describe Mumuki::Domain::Helpers::User do
+  let(:json) { {
+    uid: 'foo@bar.com',
+    image_url: 'image.png',
+    email: 'foo@bar.com',
+    first_name: 'Jon',
+    last_name: 'Doe',
+    permissions: {}} }
+  let(:user) { User.new json }
+  let(:organization) { Organization.new name: 'foo' }
+
+  it { expect(user.name).to eq 'Jon Doe' }
+  it { expect(user.full_name).to eq 'Jon Doe' }
+  it { expect(user.writer?).to be false }
+  it { expect(user.student?).to be false }
+  it { expect(user.platform_event_name(:changed)).to eq 'UserChanged' }
+  it { expect(user.as_platform_event).to eq user: user.to_resource_h }
+
+  describe "profile_completed?" do
+    let(:empty) { User.new }
+    let(:name_only) { User.new first_name: 'Julio', last_name: 'Cortazar' }
+    let(:with_gender) { User.new first_name: 'Victoria', last_name: 'Ocampo', gender: :female }
+    let(:complete) { User.new first_name: 'Maria Elena', last_name: 'Walsh', gender: :female, birthdate: Date.new(1930, 2, 1) }
+
+    it { expect(empty).to_not be_profile_completed }
+    it { expect(name_only).to_not be_profile_completed }
+    it { expect(with_gender).to_not be_profile_completed }
+    it { expect(complete).to be_profile_completed }
+  end
+
+  describe 'make_student_of!' do
+    before { user.make_student_of! organization.slug }
+
+    it { expect(user.student?).to be true }
+    it { expect(user.student? 'bar/_').to be false }
+
+    it { expect(user.student_of? organization).to be true }
+    it { expect(user.student_of? struct(slug: 'bar/_')).to be false }
+  end
+
+  describe 'to_resource_h' do
+    it { expect(user.to_resource_h).to json_eq json }
+  end
+
+  describe 'student_here?' do
+    before { Mumukit::Platform::Organization.leave! }
+
+    context 'no organization selected' do
+      it { expect { user.student_here? }.to raise_error('organization not selected') }
+    end
+
+    context 'organization selected' do
+      before { Mumukit::Platform::Organization.switch! organization }
+
+      context 'when in organization' do
+        before { user.make_student_of! organization.slug }
+        it { expect(user.student_here?).to be true }
+      end
+
+      context 'when not in organization' do
+        it { expect(user.student_here?).to be false }
+      end
+    end
+  end
+
+
+  describe 'discusser_here?' do
+    before { Mumukit::Platform::Organization.leave! }
+
+    context 'no organization selected' do
+      it { expect { user.discusser_here? }.to raise_error('organization not selected') }
+    end
+
+    context 'organization selected' do
+      before { Mumukit::Platform::Organization.switch! organization }
+      before { organization.forum_discussions_minimal_role = :student }
+
+      context 'when student is minimal discusser permission' do
+        context 'when in organization not as student' do
+          it { expect(user.discusser_here?).to be false }
+        end
+
+        context 'when in organization as student' do
+          before { user.make_student_of! organization.slug }
+          it { expect(user.discusser_here?).to be true }
+        end
+      end
+
+      context 'when teacher is minimal discusser permission' do
+        before { organization.forum_discussions_minimal_role = :teacher }
+
+        context 'when in organization not as student' do
+          it { expect(user.discusser_here?).to be false }
+        end
+
+        context 'when in organization as student' do
+          before { user.make_student_of! organization.slug }
+          it { expect(user.discusser_here?).to be false }
+        end
+
+        context 'when in organization as teacher' do
+          before { user.make_teacher_of! organization.slug }
+          it { expect(user.discusser_here?).to be true }
+        end
+      end
+
+      context 'when not in organization' do
+        it { expect(user.discusser_here?).to be false }
+      end
+    end
+  end
+
+  describe 'student_granted_organizations' do
+    before { Mumukit::Platform.config.organization_class = class_double('UserSpecDemoOrganization') }
+
+    context 'no organization' do
+      it { expect(user.student_granted_organizations).to eq [] }
+      it { expect(user.has_student_granted_organizations?).to be false }
+      it { expect(user.has_main_organization?).to be false }
+      it { expect(user.has_immersive_main_organization?).to be false }
+    end
+
+    context 'with organization' do
+      before { user.make_student_of! organization.slug }
+      before { expect(Mumukit::Platform.organization_class).to receive(:find_by_name!).and_return(organization)}
+
+      it { expect(user.student_granted_organizations).to eq [organization] }
+      it { expect(user.has_student_granted_organizations?).to be true }
+      it { expect(user.has_main_organization?).to be true }
+      it { expect(user.has_immersive_main_organization?).to be false }
+
+      context 'when immersive' do
+        before { organization.settings.immersive = true }
+        it { expect(user.has_immersive_main_organization?).to be true }
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/api_client_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe ApiClient, type: :model do
+  let(:api_client) {create :api_client}
+  it {expect { Mumukit::Auth::Token.decode(api_client.token).verify_client!}.to_not raise_error }
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/assignment_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Assignment, organization_workspace: :test do
+
+  describe 'messages' do
+    let(:student) { create(:user) }
+    let(:problem) { create(:problem, manual_evaluation: true) }
+    let(:assignment) { problem.assignment_for(student) }
+    let(:message) { assignment.messages.first }
+
+    before { problem.submit_solution! student, content: '...' }
+
+    describe '.send_question!' do
+      before { problem.submit_question! student, content: 'How can i solve this?' }
+
+      it { expect(assignment.new_record?).to be false }
+      it { expect(assignment.has_messages?).to be true }
+      it { expect(message.sender).to eq student.uid }
+      it { expect(message.content).to eq 'How can i solve this?' }
+      it { expect(message.read).to be true }
+      it { expect(message.assignment).to eq assignment }
+      it { expect(message.submission_id).to eq assignment.submission_id }
+      it { expect(message.date).to_not be nil }
+    end
+
+    describe '.receive_answer!' do
+      before { problem.submit_question! student, content: 'How can i solve this?' }
+      before { assignment.receive_answer! sender: 'bot@mumuki.org', content: 'Check this link' }
+
+      it { expect(assignment.has_messages?).to be true }
+      it { expect(assignment.messages.count).to eq 2 }
+      it { expect(message.sender).to eq 'bot@mumuki.org' }
+      it { expect(message.content).to eq 'Check this link' }
+      it { expect(message.read).to be false }
+      it { expect(message.assignment).to eq assignment }
+      it { expect(message.submission_id).to eq assignment.submission_id }
+    end
+  end
+
+  describe 'manual evaluation' do
+    let(:user) { create(:user) }
+    let(:exercise) { create(:exercise, manual_evaluation: true, test: nil, expectations: []) }
+    let(:assignment) { exercise.submit_solution!(user, content: '') }
+
+    it { expect(assignment.status).to eq :manual_evaluation_pending }
+  end
+
+  describe '#results_visible?' do
+    let(:gobstones) { create(:language, visible_success_output: true) }
+    let(:gobstones_exercise) { create(:exercise, language: gobstones) }
+
+    let(:failed_submission) { create(:assignment, status: :failed) }
+    let(:passed_submission) { create(:assignment, status: :passed, expectation_results: []) }
+    let(:passed_submission_with_visible_output_language) { create(:assignment, status: :passed, exercise: gobstones_exercise) }
+    let(:manual_evaluation_pending_submission) { create(:assignment, status: :manual_evaluation_pending) }
+
+    it { expect(passed_submission.results_visible?).to be false }
+    it { expect(failed_submission.should_retry?).to be true }
+    it { expect(failed_submission.results_visible?).to be true }
+    it { expect(passed_submission_with_visible_output_language.results_visible?).to be true }
+    it { expect(manual_evaluation_pending_submission.results_visible?).to be false }
+  end
+
+  describe '#expectation_results_visible?' do
+    let(:haskell) { create(:language, visible_success_output: true) }
+    let(:exercise) { create(:exercise) }
+    context 'should show expectation with failed submissions' do
+      let(:failed_submission) { create(:assignment, status: :failed, expectation_results: [{binding: "foo", inspection: "HasBinding", result: :failed}]) }
+      it { expect(failed_submission.expectation_results_visible?).to be true }
+      it { expect(failed_submission.failed_expectation_results.size).to eq 1 }
+    end
+    context 'should show expectation with errored submissions' do
+      let(:errored_submission) { create(:assignment, status: :errored, expectation_results: [{binding: "foo", inspection: "HasBinding", result: :failed}]) }
+      it { expect(errored_submission.expectation_results_visible?).to be true }
+    end
+  end
+
+  describe '#showable_results_visible?' do
+    let(:failed_submission) { create(:assignment, exercise: problem, status: :failed, expectation_results: [{binding: "foo", inspection: "HasBinding", result: :failed},
+                                                                                                            {binding: "bar", inspection: "HasBinding", result: :failed}]) }
+
+    context 'should show all failed expectation results for regular problems' do
+      let(:problem) { create(:problem) }
+      it { expect(failed_submission.visible_expectation_results.size).to eq 2 }
+    end
+
+    context 'should show only the first failed expectation result for kids problems' do
+      let(:problem) { create(:problem, layout: 'input_kids') }
+      it { expect(failed_submission.visible_expectation_results.size).to eq 1 }
+    end
+  end
+
+  describe '#run_update!' do
+    let(:assignment) { create(:assignment) }
+    context 'when run passes unstructured' do
+      before { assignment.run_update! { {result: 'ok', status: :passed} } }
+      it { expect(assignment.status).to eq(:passed) }
+      it { expect(assignment.result).to eq('ok') }
+    end
+
+    context 'when run fails unstructured' do
+      before { assignment.run_update! { {result: 'ups', status: :failed} } }
+      it { expect(assignment.status).to eq(:failed) }
+      it { expect(assignment.result).to eq('ups') }
+    end
+
+    context 'when run aborts unstructured' do
+      before { assignment.run_update! { {result: 'took more thn 4 seconds', status: :aborted} } }
+      it { expect(assignment.status).to eq(:aborted) }
+      it { expect(assignment.result).to eq('took more thn 4 seconds') }
+    end
+
+    context 'when run passes with warnings unstructured' do
+      let(:runner_response) do
+        {status: :passed_with_warnings,
+         test_results: [{title: 'true is true', status: :passed, result: ''},
+                        {title: 'false is false', status: :passed, result: ''}],
+         expectation_results: [{binding: 'bar', inspection: 'HasBinding', result: :passed},
+                               {binding: 'foo', inspection: 'HasBinding', result: :failed}],
+         feedback: 'foo'}
+      end
+      before { assignment.run_update! { runner_response } }
+
+      it { expect(assignment.status).to eq(:passed_with_warnings) }
+      it { expect(assignment.result).to be_blank }
+      it { expect(assignment.test_results).to eq(runner_response[:test_results]) }
+      it { expect(assignment.expectation_results).to eq(runner_response[:expectation_results]) }
+      it { expect(assignment.feedback).to eq('foo') }
+    end
+    context 'when run raises exception' do
+      before do
+        begin
+          assignment.run_update! { raise 'ouch' }
+        rescue
+        end
+      end
+      it { expect(assignment.status).to eq(:errored) }
+      it { expect(assignment.result).to eq('ouch') }
+    end
+  end
+
+  describe '#update_submissions_count!' do
+    let(:exercise) { create(:exercise) }
+    let(:user) { create(:user) }
+
+    before do
+      exercise.submit_solution!(user)
+      exercise.submit_solution!(user)
+      exercise.submit_solution!(user)
+    end
+
+    it { expect(exercise.reload.submissions_count).to eq(3) }
+  end
+
+  describe 'organization' do
+    let(:exercise) { create(:exercise) }
+    let(:user) { create(:user) }
+
+    context 'when solution is submitted' do
+      before { exercise.submit_solution!(user, content: 'foo') }
+
+      it 'should persist what organization it was submitted in' do
+        expect(exercise.assignment_for(user).organization).to eq Organization.current
+      end
+    end
+  end
+
+  describe '#submission_id' do
+    let(:exercise) { create(:exercise) }
+    let(:user) { create(:user) }
+
+    before { exercise.submit_solution!(user, content: 'foo') }
+
+    it do
+      submission_id = exercise.assignment_for(user).submission_id
+      expect(submission_id).to be_present
+
+      exercise.submit_solution!(user, content: 'bar')
+
+      new_submission_id = exercise.assignment_for(user).submission_id
+      expect(new_submission_id).to be_present
+      expect(new_submission_id).to_not eq submission_id
+    end
+  end
+
+  describe '#evaluate_manually!' do
+
+    let(:user) { create(:user) }
+    let(:exercise) { create(:exercise, manual_evaluation: true, test: nil, expectations: []) }
+    let(:assignment) { exercise.submit_solution!(user, content: '') }
+    let(:evaluated_assignment) { Assignment.find assignment.id }
+
+    before { Assignment.evaluate_manually! submission_id: assignment.submission_id, manual_evaluation: '**Good**', status: 'passed_with_warnings' }
+
+    it { expect(evaluated_assignment.status).to eq :passed_with_warnings }
+    it { expect(evaluated_assignment.manual_evaluation_comment).to eq '**Good**' }
+  end
+
+  describe '#extra' do
+    let(:user) { create(:user, email: 'some_email', first_name: 'some_first_name', last_name: 'some_last_name') }
+    let(:exercise) { create(:exercise, extra: "/*...user_email...*/\n/*...user_first_name...*/\n/*...user_last_name...*/") }
+    let(:assignment) { exercise.submit_solution!(user, content: '') }
+
+    it { expect(assignment.extra).to eq "some_email\nsome_first_name\nsome_last_name\n" }
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/book_import_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Book do
+  let!(:haskell) { create(:haskell) }
+  let!(:gobstones) { create(:gobstones) }
+
+  let!(:guide_1) { create(:guide, name: 'a lesson') }
+  let!(:guide_2) { create(:guide, name: 'other lesson') }
+
+  let!(:topic_1) { create(:topic, name: 'a topic') }
+  let!(:topic_2) { create(:topic, name: 'other topic') }
+
+
+  let(:book_resource_h) do
+    {name: 'sample book',
+      description: 'a sample book description',
+      slug: 'mumuki/a-book',
+      locale: 'en',
+      chapters: [topic_1.slug, topic_2.slug],
+      complements: complement_slugs,
+    }
+  end
+
+  let(:complement_slugs) { [] }
+
+  describe '#sync_key' do
+    let(:book) { create(:book, slug: 'mumuki/a-book') }
+
+    it { expect(book.sync_key).to eq Mumukit::Sync.key(Book, 'mumuki/a-book')}
+  end
+
+  describe '.import_from_resource_h!' do
+    let(:book) { Book.import_from_resource_h! book_resource_h }
+
+    it { expect(book.sync_key).to eq Mumukit::Sync.key(Book, 'mumuki/a-book') }
+  end
+
+  describe '#import_from_resource_h!', organization_workspace: :test do
+    let(:book) { Organization.current.book }
+
+    context 'when complements are present' do
+      let(:complement_slugs) { [guide_2.slug, guide_1.slug] }
+
+      before { book.import_from_resource_h!(book_resource_h) }
+
+      it 'imports data succesfully' do
+        expect(book.name).to eq 'sample book'
+        expect(book.description).to eq 'a sample book description'
+        expect(book.locale).to eq 'en'
+        expect(book.chapters.count).to eq 2
+        expect(book.complements.count).to eq 2
+      end
+
+      it 'reindexes usages properly' do
+        expect(topic_2.reload.usage_in_organization).to be_a Chapter
+        expect(guide_2.reload.usage_in_organization).to be_a Complement
+      end
+
+      it { expect(book.sync_key).to eq Mumukit::Sync.key(Book, 'mumuki/a-book') }
+    end
+
+    context 'when complements are not present' do
+      let(:complement_slugs) { ['foo/bar', guide_1.slug] }
+
+      before { book.import_from_resource_h!(book_resource_h) }
+
+      it { expect(book.complements.count).to eq 1 }
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/book_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Book, organization_workspace: :test do
+  let(:book) { Organization.current.book }
+
+  describe 'book normalization' do
+    let(:book) { create(:book, slug: 'fLbUlGaReLlI/MuMUkI-saMPle-gUIde') }
+
+    it { expect(book.slug).to eq('flbulgarelli/mumuki-sample-guide') }
+  end
+
+  describe 'fork_to!' do
+    let(:original_book) do
+      create(:book,
+        slug: 'original/book',
+        chapters: [
+          create(:chapter,
+            slug: 'original/topic1',
+            lessons: [
+              create(:lesson, slug: 'original/guide1'),
+              create(:lesson, slug: 'original/guide2')]),
+          create(:chapter,
+            slug: 'original/topic2',
+            lessons: [
+              create(:lesson, slug: 'original/guide3'),
+              create(:lesson, slug: 'original/guide4')])])
+    end
+
+    let(:new_guides) { new_book.reload.chapters.map(&:topic).flat_map(&:lessons).map(&:guide) }
+
+    shared_examples_for 'a successful fork operation' do
+      let!(:new_book) { original_book.fork_to! 'new', Mumukit::Sync::Syncer.new(Mumukit::Sync::Store::NullStore.new) }
+
+      it "forks properly" do
+        expect(new_book.slug).to eq 'new/book'
+        expect(new_book.chapters.map(&:slug)).to eq %w(new/topic1 new/topic2)
+        expect(new_guides.map(&:slug)).to eq %w(new/guide1 new/guide2 new/guide3 new/guide4)
+
+        expect(Book.find_by_slug 'new/book').to be_present
+        expect(Topic.find_by_slug 'new/topic1').to be_present
+        expect(Topic.find_by_slug 'new/topic2').to be_present
+        expect(Guide.find_by_slug 'new/guide1').to be_present
+        expect(Guide.find_by_slug 'new/guide2').to be_present
+        expect(Guide.find_by_slug 'new/guide3').to be_present
+        expect(Guide.find_by_slug 'new/guide4').to be_present
+      end
+    end
+
+    context 'when no content has been previously forked' do
+      it_behaves_like 'a successful fork operation'
+    end
+
+    context 'when some content has been previously forked' do
+      before { create :guide, slug: 'new/guide2' }
+      before { create :guide, slug: 'new/guide4' }
+
+      it_behaves_like 'a successful fork operation'
+    end
+  end
+
+  describe '#next_lesson_for' do
+    let!(:chapter) { create(:chapter, lessons: [create(:lesson)]) }
+    let(:fresh_user) { create(:user) }
+
+    before { reindex_current_organization! }
+
+    it { expect(book.next_lesson_for(nil)).to eq book.first_lesson }
+    it { expect(book.next_lesson_for(fresh_user)).to eq book.first_lesson }
+  end
+
+  describe '#rebuild!' do
+    let(:chapter_1) { build(:chapter, number: 10) }
+    let(:chapter_2) { build(:chapter, number: 8) }
+
+    let(:lesson_1) { create(:lesson) }
+    let(:lesson_2) { create(:lesson) }
+    let(:lesson_3) { create(:lesson) }
+
+    let(:guide_1) { lesson_1.guide }
+    let(:guide_2) { lesson_2.guide }
+    let(:guide_3) { lesson_3.guide }
+
+    context 'when chapter is rebuilt after book rebuilt' do
+      before do
+        book.description = '#foo'
+        book.rebuild!([chapter_1, chapter_2])
+
+        chapter_1.rebuild!([lesson_1, lesson_2])
+        chapter_2.rebuild!([lesson_3])
+      end
+
+
+      it "rebuilds successfully" do
+        expect(book.description).to eq '#foo'
+        expect(book.description_html).to eq "<h1>foo</h1>\n"
+
+        expect(Chapter.count).to eq 2
+        expect(book.chapters).to eq [chapter_1, chapter_2]
+        expect(chapter_1.guides).to eq [guide_1, guide_2]
+        expect(chapter_2.guides).to eq [guide_3]
+        expect(chapter_1.number).to eq 1
+        expect(chapter_2.number).to eq 2
+      end
+    end
+
+    context 'when some chapters are orphan' do
+      let(:orphan_chapter) { build(:chapter, book: nil) }
+      before do
+        book.description = '#foo'
+        book.rebuild!([chapter_1, orphan_chapter, chapter_2])
+
+        chapter_1.rebuild!([lesson_1, lesson_2])
+        chapter_2.rebuild!([lesson_3])
+      end
+
+      it "rebuilds successfully" do
+        expect(book.description).to eq '#foo'
+        expect(book.description_html).to eq "<h1>foo</h1>\n"
+
+        expect(Chapter.count).to eq 3
+        expect(book.chapters).to eq [chapter_1, orphan_chapter, chapter_2]
+        expect(chapter_1.guides).to eq [guide_1, guide_2]
+        expect(chapter_2.guides).to eq [guide_3]
+        expect(chapter_1.number).to eq 1
+        expect(orphan_chapter.number).to eq 2
+        expect(chapter_2.number).to eq 3
+      end
+    end
+
+
+    context 'when chapter is created before book rebuilt' do
+      before do
+        chapter_1.save!
+        chapter_2.save!
+
+        book.description = '#foo'
+        book.rebuild!([chapter_1, chapter_2])
+
+        chapter_1.rebuild!([lesson_1, lesson_2])
+        chapter_2.rebuild!([lesson_3])
+      end
+
+      it "rebuilds successfully" do
+        expect(book.description).to eq '#foo'
+        expect(book.description_html).to eq "<h1>foo</h1>\n"
+
+        expect(Chapter.count).to eq 2
+        expect(book.chapters).to eq [chapter_1, chapter_2]
+        expect(chapter_1.guides).to eq [guide_1, guide_2]
+        expect(chapter_2.guides).to eq [guide_3]
+        expect(chapter_1.number).to eq 1
+        expect(chapter_2.number).to eq 2
+      end
+    end
+
+    context 'when chapter is rebuilt before book rebuilt' do
+      before do
+        chapter_1.rebuild!([lesson_1, lesson_2])
+        chapter_2.rebuild!([lesson_3])
+
+        book.description = '#foo'
+        book.rebuild!([chapter_1, chapter_2])
+      end
+
+      it "rebuilds successfully" do
+        expect(book.description).to eq '#foo'
+        expect(book.description_html).to eq "<h1>foo</h1>\n"
+
+        expect(Chapter.count).to eq 2
+        expect(book.chapters).to eq [chapter_1, chapter_2]
+        expect(chapter_1.number).to eq 1
+        expect(chapter_2.number).to eq 2
+        expect(chapter_1.guides).to eq [guide_1, guide_2]
+        expect(chapter_2.guides).to eq [guide_3]
+      end
+    end
+  end
+end