mumuki-laboratory 7.10.5 → 7.11.0

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-2e15c3330133/spec/models/hash_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Hash do
+  describe 'markdownified!' do
+    let(:hash) { { something: 'hello **world**', something_else: '`the code`', other: '_foo_' } }
+
+    context 'without options' do
+      before { hash.markdownified! :something, :something_else }
+      it { expect(hash).to eq other: "_foo_", something: "<p>hello <strong>world</strong></p>\n", something_else: "<p><code>the code</code></p>\n" }
+    end
+
+    context 'with options' do
+      before { hash.markdownified! :something, :something_else, one_liner: true }
+      it { expect(hash).to eq other: "_foo_", something: "hello <strong>world</strong>", something_else: "<code>the code</code>" }
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-2e15c3330133/spec/models/incognito_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Mumuki::Domain::Incognito do
+  let(:user) { Mumuki::Domain::Incognito }
+  let(:organization) { create(:organization) }
+
+  it 'can mock an AR relation' do
+    Assignment.new submitter: user
+  end
+
+  describe 'ensure_enabled!' do
+    it { expect { user.ensure_enabled! }.to_not raise_error }
+  end
+
+  describe 'assignment fooling' do
+    let(:assignment) { user.build_assignment(exercise, organization) }
+
+    context 'when exercise has no default content' do
+      let(:exercise) { create(:exercise) }
+
+      it { expect(assignment).to be_an Assignment }
+      it { expect(assignment.submitter).to be user }
+      it { expect(assignment.current_content).to eq '' }
+    end
+
+    context 'when exercise has default content' do
+      let(:exercise) { create(:exercise, default_content: '...') }
+
+      it { expect(assignment.current_content).to eq '...' }
+    end
+  end
+
+  describe 'guide fooling' do
+    let(:guide) { create(:guide, exercises: [ create(:exercise), create(:exercise) ]) }
+
+    describe 'completion_percentage_for', organization_workspace: :test do
+      it { expect(guide.completion_percentage_for(user)).to eq 0 }
+    end
+
+    describe 'next_exercise', organization_workspace: :test do
+      # TODO this looks weird. Why do we need a non-polymorphic
+      # next_exercise? Aren't indicators not enought?
+      it { expect(guide.next_exercise(user)).to eq guide.exercises.first }
+    end
+  end
+
+  describe 'exercise fooling' do
+    let(:problem) { create(:problem) }
+
+    describe 'next_for' do
+      it { expect(problem.next_for(user)).to be nil }
+    end
+
+    describe 'try_submit_solution!', organization_workspace: :test do
+      let!(:chapter) do
+        create(:chapter, name: 'Functional Programming', lessons: [
+          create(:lesson, exercises: [problem])
+        ])
+      end
+      let(:bridge_response) { {result: '0 failures', status: :passed} }
+
+      before { reindex_current_organization! }
+      before { expect_any_instance_of(Language).to receive(:run_tests!).and_return(bridge_response) }
+
+      let!(:assignment) { problem.try_submit_solution!(user) }
+
+      it { expect(assignment).to_not be nil }
+      it { expect(assignment.status).to be_like :passed }
+    end
+  end
+
+  describe 'immersive context fooling' do
+    context 'no immersive organizations' do
+      it { expect(user.immersive_organizations_at(nil)).to be_empty }
+    end
+
+    context 'no current immersive context' do
+      it { expect(user.current_immersive_context_at(nil)).to be_nil }
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-2e15c3330133/spec/models/indicator_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Indicator, organization_workspace: :test do
+  let(:user) { create(:user) }
+
+  let(:exercise) { create :exercise, guide: guide }
+  let(:sibling_exercise) { create :exercise, guide: sibling_guide }
+  let(:guide) { create :indexed_guide }
+  let(:topic) { guide.chapter.topic }
+  let(:book) { guide.chapter.book }
+  let!(:sibling_lesson) { create :lesson, topic: topic }
+  let(:sibling_guide) { sibling_lesson.guide }
+
+  let(:guide_indicator) { Indicator.find_by user: user, content: guide }
+  let(:sibling_guide_indicator) { Indicator.find_by user: user, content: sibling_guide }
+  let(:topic_indicator) { Indicator.find_by user: user, content: topic }
+  let(:book_indicator) { Indicator.find_by user: user, content: book }
+
+  before { reindex_current_organization! }
+
+  let!(:assignment) { exercise.submit_solution!(user, content: 'foo').tap(&:passed!) }
+
+  context 'on submission' do
+    context 'tree is created when submission is sent' do
+      it { expect(Assignment.count).to eq 1 }
+      it { expect(Indicator.count).to eq 3 }
+      it { expect(assignment.parent).to eq guide_indicator }
+      it { expect(guide_indicator.parent).to eq topic_indicator }
+      it { expect(topic_indicator.parent).to eq book_indicator }
+      it { expect(book_indicator.parent).to be_nil }
+    end
+
+    context 'dirtiness' do
+      let!(:sibling_assignment) { sibling_exercise.submit_solution!(user, content: 'foo').tap(&:passed!) }
+
+      context 'indicator rebuild is not propagated up' do
+        before { guide_indicator.rebuild! }
+
+        it { expect(guide_indicator).to_not be_dirty_by_submission }
+        it { expect(topic_indicator).to be_dirty_by_submission }
+        it { expect(book_indicator).to be_dirty_by_submission }
+      end
+
+      context 'when indicators are not dirty' do
+        before { Indicator.update_all dirty_by_content_change: false, dirty_by_submission: false }
+        before { assignment.reload }
+
+        context 'it is dirtied when submission changes completion status' do
+          before { assignment.errored!('something went wrong!') }
+
+          it { expect(guide_indicator).to be_dirty_by_submission }
+
+          context 'dirtiness is propagated upwards' do
+            it { expect(topic_indicator).to be_dirty_by_submission }
+            it { expect(book_indicator).to be_dirty_by_submission }
+
+            it { expect(sibling_guide_indicator).to_not be_dirty_by_submission }
+          end
+        end
+
+        context 'it is not dirtied when submission does not change completion status' do
+          before { assignment.reload }
+          before { assignment.passed! }
+
+          it { expect(guide_indicator).to_not be_dirty_by_submission }
+        end
+      end
+    end
+  end
+
+  context 'on content change' do
+    context 'when children do not change' do
+      before { guide.import_from_resource_h!(guide.to_resource_h.merge description: 'foo') }
+
+      it { expect(guide_indicator).to_not be_dirty_by_content_change }
+    end
+
+    context 'when children change' do
+      let(:new_exercise_h) { build(:exercise).to_resource_h }
+
+      before { guide.import_from_resource_h!(guide.to_resource_h.merge exercises: [new_exercise_h]) }
+
+      it { expect(guide_indicator).to be_dirty_by_content_change }
+
+      context 'dirtiness is not propagated up' do
+        it { expect(topic_indicator).to_not be_dirty_by_content_change }
+        it { expect(book_indicator).to_not be_dirty_by_content_change }
+      end
+
+      context 'indicator rebuild is propagated up' do
+        before { guide_indicator.completed? }
+
+        it { expect(guide_indicator).to_not be_dirty_by_content_change }
+        it { expect(topic_indicator).to_not be_dirty_by_content_change }
+        it { expect(book_indicator).to_not be_dirty_by_content_change }
+        it { expect(topic_indicator).to_not be_dirty_by_submission }
+        it { expect(book_indicator).to_not be_dirty_by_submission }
+      end
+    end
+
+    context 'past children should not affect new progress tree' do
+      before { topic_indicator.send :children_count }
+      before { topic.import_from_resource_h!(topic.to_resource_h.merge lessons: []) }
+
+      it { expect(topic_indicator.reload.send :children_count).to eq 0 }
+      it { expect(topic_indicator.reload.send :children_passed_count).to eq 0 }
+    end
+  end
+
+  context 'completion' do
+    describe 'content is completed' do
+      it { expect(guide_indicator).to be_completed }
+      it { expect(guide_indicator).to be_once_completed }
+    end
+
+    describe 'content was once completed if failed afterwards' do
+      before do
+        assignment.reload
+        guide_indicator.reload.rebuild!
+        assignment.failed!
+        guide_indicator.reload.rebuild!
+      end
+
+      it { expect(guide_indicator).to_not be_completed }
+      it { expect(guide_indicator).to be_once_completed }
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-2e15c3330133/spec/models/interactive_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Interactive, organization_workspace: :test do
+  let(:guide) { create(:indexed_guide) }
+  let!(:interactive) { create(:interactive, guide: guide) }
+  let!(:user) { create(:user) }
+  let(:assignment) { interactive.assignment_for(user) }
+  let!(:bridge) { double(:bridge) }
+  before { allow_any_instance_of(Language).to receive(:bridge).and_return bridge }
+
+  context 'before even trying' do
+    it { expect(assignment.queries).to eq [] }
+    it { expect(assignment.query_results).to be_blank }
+    it { expect(assignment.status).to eq :pending }
+    it { expect(assignment.result).to be_blank }
+  end
+
+  context 'on first, failing try' do
+    before do
+      expect(bridge)
+        .to receive(:run_try!).and_return status: :failed,
+                                          result: '',
+                                          query_result: {
+                                            status: :passed,
+                                            result: 'foo out'
+                                          }
+
+    end
+
+    before { interactive.submit_try!(user, query: 'foo') }
+
+    it { expect(assignment.queries).to eq ['foo'] }
+    it { expect(assignment.query_results).to eq [{status: :passed, result: "foo out"}] }
+    it { expect(assignment.queries_with_results).to eq [{query: 'foo', status: :passed, result: "foo out"}] }
+    it { expect(assignment.status).to eq :failed }
+    it { expect(assignment.result).to eq '' }
+  end
+
+  context 'on second, failing try' do
+    before do
+      expect(bridge)
+        .to receive(:run_try!).and_return({status: :failed,
+                                           result: '',
+                                           query_result: { status: :passed, result: 'foo out' }},
+                                          {status: :failed,
+                                           result: '',
+                                           query_result: { status: :failed, result: 'bar out' }})
+
+    end
+
+
+    before do
+      interactive.submit_try!(user, query: 'foo')
+      interactive.submit_try!(user, query: 'bar', cookie: ['foo'])
+    end
+
+    it { expect(assignment.queries).to eq ['foo', 'bar'] }
+    it { expect(assignment.query_results).to eq [
+                                                {status: :passed, result: 'foo out'},
+                                                {status: :failed, result: 'bar out'}] }
+    it { expect(assignment.queries_with_results).to eq [
+                                                {query: 'foo', status: :passed, result: 'foo out'},
+                                                {query: 'bar', status: :failed, result: 'bar out'}] }
+
+    it { expect(assignment.status).to eq :failed }
+    it { expect(assignment.result).to be_blank }
+  end
+
+  context 'on third, passing try' do
+    before do
+      expect(bridge)
+        .to receive(:run_try!).and_return({status: :failed,
+                                           result: '',
+                                           query_result: { status: :passed, result: 'foo out' }},
+                                          {status: :failed,
+                                           result: '',
+                                           query_result: { status: :failed, result: 'bar out' }},
+                                          {status: :passed,
+                                           result: 'foobaz',
+                                           query_result: { status: :passed, result: 'baz out' }})
+
+    end
+
+
+    before do
+      interactive.submit_try!(user, query: 'foo')
+      interactive.submit_try!(user, query: 'bar', cookie: ['foo'])
+      interactive.submit_try!(user, query: 'baz', cookie: ['foo', 'bar'])
+    end
+
+    it { expect(assignment.queries).to eq ['foo', 'bar', 'baz'] }
+    it { expect(assignment.query_results).to eq [
+                                                {status: :passed, result: 'foo out'},
+                                                {status: :failed, result: 'bar out'},
+                                                {status: :passed, result: 'baz out'}] }
+    it { expect(assignment.status).to eq :passed }
+    it { expect(assignment.result).to eq 'foobaz' }
+  end
+
+
+  context 'on first failing try after reset' do
+    before do
+      expect(bridge)
+        .to receive(:run_try!).and_return({status: :failed,
+                                           result: '',
+                                           query_result: { status: :passed, result: 'foo out' }},
+                                          {status: :failed,
+                                           result: '',
+                                           query_result: { status: :failed, result: 'bar out' }},
+                                          {status: :failed,
+                                           result: '',
+                                           query_result: { status: :failed, result: 'goo out' }})
+
+    end
+
+
+    before do
+      interactive.submit_try!(user, query: 'foo')
+      interactive.submit_try!(user, query: 'bar', cookie: ['foo'])
+      interactive.submit_try!(user, query: 'goo')
+    end
+
+    it { expect(assignment.queries).to eq ['goo'] }
+    it { expect(assignment.query_results).to eq [{status: :failed, result: 'goo out'}] }
+    it { expect(assignment.status).to eq :failed }
+    it { expect(assignment.result).to be_blank }
+  end
+
+  context 'on aborted try with no query_result' do
+    before do
+      expect(bridge).to receive(:run_try!).and_return({status: :aborted, result: ''})
+    end
+
+    before do
+      interactive.submit_try!(user, query: 'foo')
+    end
+
+    it { expect(assignment.queries).to eq ['foo'] }
+    it { expect(assignment.query_results).to eq [] }
+    it { expect(assignment.status).to eq :aborted }
+    it { expect(assignment.result).to eq 'Oops, something went wrong in Mumuki. Restart the exercise, wait a few seconds and try again.'}
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-2e15c3330133/spec/models/invitation_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Invitation, organization_workspace: :test do
+  let(:course) { create :course, slug: 'test/bar' }
+
+  describe '.import_from_resource_h!' do
+    let(:invitation) { Invitation.import_from_resource_h! code: 'eZNvuQ', course: course.slug, expiration_date: 2.days.since }
+
+    it { expect(invitation).to_not be nil }
+    it { expect(invitation.code).to eq 'eZNvuQ' }
+    it { expect(invitation.course_slug).to eq 'test/bar' }
+  end
+
+  describe '#unexpired' do
+    let(:invitation) { create(:invitation, expiration_date: 5.minutes.since, course: course) }
+    context 'when expired' do
+      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
+      it { expect(invitation.unexpired).to eq invitation }
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-2e15c3330133/spec/models/language_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Language do
+  describe 'name uniqness' do
+    let!(:gobstones) { create(:language, name: 'Gobstones') }
+
+    it { expect { create :language, name: 'gobstones' }.to raise_exception(ActiveRecord::RecordInvalid) }
+    it { expect(Language.for_name 'gobstones').to eq gobstones }
+    it { expect(Language.for_name nil).to be nil}
+  end
+
+  describe '#import!' do
+    subject { create(:language, name: 'gobstones', runner_url: 'http://runner.com') }
+    before { subject.import_from_resource_h! language_resource_h }
+
+    let(:language_resource_h) { {
+      name: "gobstones",
+      comment_type: nil,
+      runner_url: "http://foo",
+      output_content_type: "html",
+      prompt: "ム ",
+      extension: "gbs",
+      highlight_mode: "gobstones",
+      visible_success_output: true,
+      devicon: nil,
+      triable: false,
+      feedback: true,
+      queriable: false,
+      stateful_console: false,
+      test_extension: "yml",
+      test_template: nil,
+      layout_js_urls: ['http://runner.com/javascripts/a.js'],
+      layout_html_urls: ["http://runner.com/b.html", "http://runner.com/c.html"],
+      layout_css_urls: ["http://runner.com/stylesheets/d.css"],
+      editor_js_urls: ['http://runner.com/javascripts/aa.js'],
+      editor_html_urls: ["http://runner.com/bb.html", "http://runner.com/cc.html"],
+      editor_css_urls: ["http://runner.com/stylesheets/dd.css"]
+    } }
+
+    it { expect(subject.name).to eq 'gobstones' }
+    it { expect(subject.queriable).to be false }
+    it { expect(subject.output_content_type).to eq Mumukit::ContentType::Html }
+    it { expect(subject.visible_success_output).to be true }
+    it { expect(subject.highlight_mode).to eq 'gobstones' }
+    it { expect(subject.devicon).to eq 'gobstones' }
+    it { expect(subject.prompt).to eq 'ム ' }
+    it { expect(subject.stateful_console).to be false }
+    it { expect(subject.feedback).to be true }
+    it { expect(subject.layout_js_urls).to eq ['http://runner.com/javascripts/a.js'] }
+    it { expect(subject.layout_html_urls).to eq ['http://runner.com/b.html', 'http://runner.com/c.html'] }
+    it { expect(subject.layout_css_urls).to eq ['http://runner.com/stylesheets/d.css'] }
+    it { expect(subject.editor_js_urls).to eq ['http://runner.com/javascripts/aa.js'] }
+    it { expect(subject.editor_html_urls).to eq ['http://runner.com/bb.html', 'http://runner.com/cc.html'] }
+    it { expect(subject.editor_css_urls).to eq ['http://runner.com/stylesheets/dd.css'] }
+  end
+end