mumuki-laboratory 7.7.1 → 7.7.6

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

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

@@ -1,101 +0,0 @@
-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.completed? }
-
-        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
-  end
-end

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

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

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

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

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

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-describe Lesson, organization_workspace: :test do
-  let(:user) { create(:user) }
-  describe '#friendly' do
-    let!(:chapter) {
-      create(:chapter, lessons: [
-          create(:lesson),
-          create(:lesson)
-      ]) }
-
-    let(:lesson) { chapter.lessons.second }
-
-    before { reindex_current_organization! }
-
-    it { expect(lesson.friendly).to eq "#{chapter.name}: #{lesson.name}" }
-  end
-
-  describe '#friendly_name' do
-    let!(:chapter) {
-      create(:chapter, name: 'Fundamentos De Programación', lessons: [
-          create(:lesson),
-          create(:lesson),
-          create(:lesson, name: 'una guía')
-      ]) }
-    let(:lesson) { chapter.lessons.third }
-
-    before { reindex_current_organization! }
-
-    it { expect(lesson.friendly_name).to eq "#{lesson.id}-fundamentos-de-programacion-una-guia" }
-  end
-
-  describe '#navigable_name' do
-    let!(:chapter) {
-      create(:chapter, lessons: [
-          create(:lesson),
-          create(:lesson)
-      ]) }
-    let(:lesson) { chapter.lessons.second }
-
-    before { reindex_current_organization! }
-
-    it { expect(lesson.navigable_name).to eq "2. #{lesson.name}" }
-  end
-
-  describe '#next_for' do
-    context 'when it is single' do
-      let!(:chapter) { create(:chapter, lessons: [
-          create(:lesson),
-          create(:lesson)
-      ]) }
-      let(:lesson) { chapter.lessons.second }
-
-      before { reindex_current_organization! }
-
-      it { expect(lesson.next_for(user)).to be nil }
-    end
-
-    context 'when there is a next guide' do
-      let!(:chapter) { create(:chapter, lessons: [
-          create(:lesson, exercises: [create(:exercise)]),
-          create(:lesson, exercises: [create(:exercise)]),
-          create(:lesson, exercises: [create(:exercise)])
-      ]) }
-      let(:lesson) { chapter.lessons.second }
-      let(:other_lesson) { chapter.lessons.third }
-
-      before { reindex_current_organization! }
-
-      it { expect(lesson.next_for(user)).to eq other_lesson }
-    end
-    context 'when there are many next guides at same level' do
-      let!(:chapter) {
-        create(:chapter, lessons: [
-            create(:lesson, exercises: [create(:exercise)]),
-            create(:lesson, exercises: [create(:exercise)]),
-            create(:lesson, exercises: [create(:exercise)]),
-            create(:lesson, exercises: [create(:exercise)])
-        ]) }
-
-      let(:lesson) { chapter.lessons.first }
-      let!(:other_lesson_1) { chapter.lessons.second }
-      let!(:other_lesson_2) { chapter.lessons.third }
-
-      before { reindex_current_organization! }
-
-      it { expect(lesson.next_for(user)).to eq other_lesson_1 }
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe Message, organization_workspace: :test do
-  describe '#parse_json' do
-    let(:data) {
-      {'exercise_id' => 1,
-       'submission_id' => 'abcdef1',
-       'message' => {
-         'sender' => 'aguspina87@gmail.com',
-         'content' => 'a',
-         'created_at' => '1/1/1'}} }
-
-    let(:expected_json) {
-      {'submission_id' => 'abcdef1',
-       'content' => 'a',
-       'created_at' => '1/1/1',
-       'sender' => 'aguspina87@gmail.com'} }
-
-    let(:parsed_comment) { Message.parse_json(data) }
-
-    it { expect(parsed_comment).to eq(expected_json) }
-  end
-
-  describe '.import_from_resource_h!' do
-    let(:user) { create(:user) }
-    let(:problem) { create(:problem) }
-
-    context 'when last submission' do
-      let!(:assignment) { problem.submit_solution! user, content: '' }
-      let(:final_assignment) { Assignment.first }
-      let(:message) { Message.first }
-
-      let!(:data) {
-        {'exercise_id' => problem.id,
-         'submission_id' => assignment.submission_id,
-         'organization' => Organization.current.name,
-         'message' => {
-           'sender' => 'teacher@mumuki.org',
-           'content' => 'a',
-           'created_at' => '1/1/1'}} }
-
-      before { Message.import_from_resource_h! data }
-      before do
-        assignment = problem.submit_solution! user, content: ''
-        Message.import_from_resource_h! 'exercise_id' => problem.id,
-                                  'submission_id' => assignment.submission_id,
-                                  'organization' => Organization.current.name,
-                                  'message' => {
-                                    'sender' => 'teacher@mumuki.org',
-                                    'content' => 'a',
-                                    'created_at' => '1/1/1'}
-      end
-
-      it { expect(Message.count).to eq 1 }
-      it { expect(message.assignment).to_not be_nil }
-      it { expect(message.assignment).to eq final_assignment }
-      it { expect(message.to_resource_h.except 'created_at', 'updated_at', 'date')
-             .to json_like submission_id: message.submission_id,
-                           content: 'a',
-                           sender: 'teacher@mumuki.org',
-                           read: false,
-                           exercise: {bibliotheca_id: problem.bibliotheca_id},
-                           organization: 'test' }
-      it { expect(final_assignment.has_messages?).to be true }
-    end
-
-    context 'when not last submission' do
-      let!(:assignment) { problem.submit_solution! user, content: '' }
-      let!(:data) {
-        {'exercise_id' => problem.id,
-         'submission_id' => assignment.submission_id,
-         'organization' => Organization.current.name,
-         'message' => {
-           'sender' => 'teacher@mumuki.org',
-           'content' => 'a',
-           'type' => 'success',
-           'created_at' => '1/1/1'}} }
-
-      before { problem.submit_solution! user, content: 'other solution' }
-      before { Message.import_from_resource_h! data }
-
-      it { expect(Message.count).to eq 0 }
-      it { expect(Assignment.first.has_messages?).to be false }
-    end
-
-  end
-end