mumuki-laboratory 6.1.5 → 6.2.0

data/spec/models/guide_import_spec.rb

@@ -1,300 +0,0 @@
-require 'spec_helper'
-
-describe Guide do
-  let!(:haskell) { create(:haskell) }
-  let!(:text) { create(:text_language) }
-  let!(:gobstones) { create(:gobstones) }
-  let(:reloaded_exercise_1) { Exercise.find(exercise_1.id) }
-
-  let(:guide_resource_h) do
-    {name: 'sample guide',
-     description: 'Baz',
-     slug: 'mumuki/sample-guide',
-     language: { name: 'haskell' },
-     locale: 'en',
-     extra: 'bar',
-     teacher_info: 'an info',
-     authors: 'Foo Bar',
-     exercises: [
-         {type: 'problem',
-          name: 'Bar',
-          description: 'a description',
-          test: 'foo bar',
-          tag_list: %w(baz bar),
-          layout: 'input_bottom',
-          teacher_info: 'an info',
-          language: { name: 'gobstones' },
-          solution: 'foo',
-          assistance_rules: [
-            {when: :content_empty, then: 'remember to copy the code in the editor!'},
-            {when: :submission_errored, then: 'remember to copy code exactly as presented'},
-          ],
-          id: 1},
-
-         {type: 'playground',
-          description: 'lorem ipsum',
-          name: 'Foo',
-          tag_list: %w(foo bar),
-          extra: 'an extra code',
-          extra_visible: true,
-          default_content: 'a default content',
-          id: 4},
-
-         {name: 'Baz',
-          description: 'lorem ipsum',
-          tag_list: %w(baz bar),
-          layout: 'input_bottom',
-          type: 'problem',
-          expectations: [{inspection: 'HasBinding', binding: 'foo'}],
-          id: 2},
-
-         {type: 'problem',
-          description: 'lorem ipsum',
-          name: 'Choice',
-          tag_list: %w(bar),
-          extra: '',
-          language: { name: 'text' },
-          test: "---\nequal: '1'\n",
-          choices: [{value: 'foo', checked: false}, {value: 'bar', checked: true}],
-          extra_visible: false,
-          id: 8},
-         {type: 'reading',
-          description: 'lorem ipsum',
-          name: 'Reading',
-          expectations: [],
-          choices: [],
-          tag_list: %w(bar),
-          language: { name: 'text' },
-          layout: 'input_bottom',
-          extra_visible: false,
-          id: 9}]}
-  end
-
-  describe '#import_from_resource_h!' do
-    context 'when an exercise is deleted' do
-      let(:guide) { create(:guide, exercises: [exercise_1, exercise_2, exercise_3, exercise_4, exercise_5, exercise_6]) }
-
-      let(:exercise_1) { build(:problem,
-                               language: haskell,
-                               name: 'Exercise 1',
-                               bibliotheca_id: 1,
-                               number: 1) }
-
-      let(:exercise_2) { build(:playground,
-                               language: haskell,
-                               name: 'Exercise 2',
-                               bibliotheca_id: 4,
-                               number: 2) }
-
-      let(:exercise_3) { build(:problem,
-                               language: haskell,
-                               name: 'Exercise 3',
-                               bibliotheca_id: 2,
-                               number: 3) }
-
-      let(:exercise_4) { create(:problem,
-                               language: haskell,
-                               name: 'Exercise 4',
-                               bibliotheca_id: 8,
-                               number: 4) }
-
-      let(:exercise_5) { create(:problem,
-                                language: haskell,
-                                name: 'Exercise 5',
-                                bibliotheca_id: 11,
-                                number: 5) }
-
-      let(:exercise_6) { create(:problem,
-                                language: haskell,
-                                name: 'Exercise 6',
-                                bibliotheca_id: 14,
-                                number: 6) }
-
-      before do
-        guide.import_from_resource_h!(guide_resource_h)
-      end
-
-      describe 'it is removed from the guide' do
-        it { expect(guide.exercises.count).to eq 5 }
-        it { expect(guide.exercises).not_to include exercise_6 }
-      end
-
-      describe 'it is deleted from the database' do
-        it { expect { Exercise.find(exercise_6.id) }.to raise_error(ActiveRecord::RecordNotFound) }
-      end
-    end
-
-    context 'when guide is empty' do
-      let(:lesson) { create(:lesson, guide: create(:guide, exercises: [])) }
-      let(:guide) { lesson.guide }
-
-      before do
-        guide.import_from_resource_h!(guide_resource_h)
-      end
-
-      it { expect(guide).to_not be nil }
-      it { expect(guide.name).to eq 'sample guide' }
-      it { expect(guide.language).to eq haskell }
-      it { expect(guide.slug).to eq 'mumuki/sample-guide' }
-      it { expect(guide.extra).to eq 'bar' }
-      it { expect(guide.description).to eq 'Baz' }
-
-      it { expect(guide.exercises.count).to eq 5 }
-      it { expect(guide.exercises.first.language).to eq gobstones }
-      it { expect(guide.exercises.first.extra_visible).to be false }
-      it { expect(guide.exercises.first.assistance_rules).to be_present }
-      it { expect(guide.exercises.first.assistant.rules.count).to eq 2 }
-
-      it { expect(guide.exercises.second.language).to eq haskell }
-      it { expect(guide.exercises.second.default_content).to eq 'a default content' }
-      it { expect(guide.exercises.second.extra_visible).to be true }
-      it { expect(guide.exercises.fourth.choices).to eq [{'value' => 'foo', 'checked' => false}, {'value' => 'bar', 'checked' => true}] }
-      it { expect(guide.exercises.fourth.choice_values).to eq ['foo', 'bar'] }
-
-      it { expect(guide.exercises.third.expectations.first['binding']).to eq 'foo' }
-
-      it { expect(guide.exercises.pluck(:name)).to eq %W(Bar Foo Baz Choice Reading) }
-    end
-
-    context 'when exercise already exists' do
-      let(:guide) { create(:guide, language: haskell, exercises: [exercise_1]) }
-
-      before do
-        guide.import_from_resource_h! guide_resource_h
-      end
-
-      context 'when exercise changes its type' do
-        let(:exercise_1) { build(:playground,
-                                 bibliotheca_id: 1,
-                                 language: haskell,
-                                 name: 'Exercise 1',
-                                 description: 'description') }
-
-        describe 'exercises are not duplicated' do
-          it { expect(guide.exercises.count).to eq 5 }
-          it { expect(Exercise.count).to eq 5 }
-        end
-
-        it { expect(guide.exercises.first).to be_instance_of(Problem) }
-        it { expect(guide.exercises.first).to eq reloaded_exercise_1 }
-      end
-
-      context 'when exercise doesnt have choices anymore' do
-        let(:exercise_1) { build(:problem,
-                                  bibliotheca_id: 1,
-                                  language: haskell,
-                                  name: 'Choices 1',
-                                  description: 'description',
-                                  hint: 'baz',
-                                  choices: ['option 1', 'option 2'],
-                                  test: 'pending',
-                                  extra: 'foo') }
-
-        it { expect(guide.exercises.first.choices?).to be false }
-      end
-
-      context 'exercises are reordered' do
-        let(:exercise_1) { create(:problem,
-                                  bibliotheca_id: 4,
-                                  language: haskell,
-                                  name: 'Exercise 1',
-                                  description: 'description',
-                                  hint: 'baz',
-                                  test: 'pending',
-                                  extra: 'foo') }
-
-        it 'identity should be preserved' do
-          expect(guide.exercises.first).to_not eq reloaded_exercise_1
-          expect(guide.exercises.second).to eq reloaded_exercise_1
-        end
-
-        it { expect(guide.exercises.pluck(:bibliotheca_id)).to eq [1, 4, 2, 8, 9] }
-
-        describe 'exercises are not duplicated' do
-          it { expect(guide.exercises.count).to eq 5 }
-          it { expect(Exercise.count).to eq 5 }
-        end
-      end
-    end
-
-    context 'when many exercises already exist' do
-      let(:guide) { create(:guide, language: haskell, exercises: [exercise_1, exercise_2]) }
-
-      let(:exercise_1) { build(:problem,
-                               language: haskell,
-                               name: 'Exercise 1',
-                               bibliotheca_id: 2,
-                               number: 1,
-                               description: 'description',
-                               corollary: 'A corollary',
-                               test: 'foo',
-                               hint: 'baz',
-                               extra: 'foo') }
-      let(:exercise_2) { build(:playground,
-                               language: haskell,
-                               name: 'Exercise 2',
-                               bibliotheca_id: 4,
-                               number: 2,
-                               description: 'description',
-                               corollary: 'A corollary',
-                               hint: 'baz',
-                               extra: 'foo') }
-      let(:reloaded_exercise_2) { Exercise.find(exercise_2.id) }
-
-      before do
-        guide.import_from_resource_h! guide_resource_h
-      end
-
-      describe 'exercises are not duplicated' do
-        it { expect(guide.exercises.count).to eq 5 }
-        it { expect(Exercise.count).to eq 5 }
-      end
-
-      it { expect(guide.exercises.first).to be_instance_of(Problem) }
-      it { expect(guide.exercises.second).to be_instance_of(Playground) }
-      it { expect(guide.exercises.third).to be_instance_of(Problem) }
-
-      it { expect(guide.exercises.second).to eq reloaded_exercise_2 }
-      it { expect(guide.exercises.third).to eq reloaded_exercise_1 }
-
-      it { expect(guide.exercises.first.number).to eq 1 }
-      it { expect(guide.exercises.second.number).to eq 2 }
-      it { expect(guide.exercises.third.number).to eq 3 }
-      it { expect(guide.exercises.fourth.number).to eq 4 }
-
-      it { expect(guide.exercises.pluck(:bibliotheca_id)).to eq [1, 4, 2, 8, 9] }
-      it { expect(guide.exercises.pluck(:id).drop(1)).to eq [reloaded_exercise_2.id, reloaded_exercise_1.id, guide.exercises.fourth.id, guide.exercises.fifth.id] }
-    end
-
-    context 'when new_expecations' do
-      let(:guide) { create(:guide, language: haskell) }
-      let(:guide_resource_h) do
-        {name: 'sample guide',
-         description: 'Baz',
-         slug: 'mumuki/sample-guide',
-         language: { name: 'haskell' },
-         locale: 'en',
-         extra: 'bar',
-         teacher_info: 'an info',
-         authors: 'Foo Bar',
-         exercises: [
-             {name: 'Baz',
-              description: 'lorem ipsum',
-              tag_list: %w(baz bar),
-              layout: 'input_bottom',
-              test: 'foo bar',
-              type: 'problem',
-              expectations: [{inspection: 'HasBinding', binding: 'foo'}],
-              new_expectations: true,
-              id: 2}]}
-      end
-
-      before do
-        guide.import_from_resource_h! guide_resource_h
-      end
-
-      it { expect(guide.exercises.first.new_expectations).to be_truthy }
-      it { expect(guide.exercises.first.expectations).to eq [] }
-    end
-  end
-end

data/spec/models/guide_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-describe Guide, organization_workspace: :test do
-  let!(:extra_user) { create(:user, first_name: 'Ignatius', last_name: 'Reilly') }
-  let(:guide) { create(:guide) }
-
-  describe '#clear_progress!' do
-    let(:an_exercise) { create(:exercise) }
-    let(:another_exercise) { create(:exercise) }
-
-    before do
-      guide.exercises = [an_exercise]
-      an_exercise.submit_solution! extra_user
-      another_exercise.submit_solution! extra_user
-      guide.clear_progress!(extra_user)
-    end
-
-    it 'destroys the guides assignments for the given user' do
-      expect(an_exercise.find_assignment_for(extra_user)).to be_nil
-    end
-
-    it 'does not destroy other guides assignments' do
-      expect(another_exercise.find_assignment_for(extra_user)).to be_truthy
-    end
-  end
-
-  describe '#fork!' do
-    let(:syncer) { double(:syncer) }
-    let!(:guide_from) { create :guide, slug: 'foo/bar' }
-    let(:slug_from) { guide_from.slug }
-    let(:slug_to) { 'baz/bar'.to_mumukit_slug }
-    let(:guide_to) { Guide.find_by_slug! slug_to.to_s }
-    let!(:guide) { create(:guide, slug: 'test/bar') }
-
-    context 'fork works' do
-      before { expect(syncer).to receive(:export!).with(instance_of(Guide)) }
-      before { Guide.find_by_slug!(slug_from).fork_to! 'baz', syncer }
-      it { expect(guide_from.to_resource_h).to json_eq guide_to.to_resource_h, except: [:slug] }
-    end
-
-    context 'fork does not work if guide already exists' do
-      before { expect(syncer).to_not receive(:export!) }
-      it { expect { Guide.find_by_slug!(slug_from).fork_to! 'test', syncer }.to raise_error ActiveRecord::RecordInvalid }
-    end
-  end
-
-  describe '#to_markdownified_resource_h' do
-    subject { guide.to_markdownified_resource_h }
-    context 'description' do
-      let(:guide) { create(:guide, description: '`foo = (+)`') }
-      it { expect(subject[:description]).to eq("<p><code>foo = (+)</code></p>\n") }
-    end
-    context 'corollary' do
-      let(:guide) { create(:guide, corollary: '[Google](https://google.com)') }
-      it { expect(subject[:corollary]).to eq("<p><a title=\"\" href=\"https://google.com\" target=\"_blank\">Google</a></p>\n") }
-    end
-    context 'teacher_info' do
-      let(:guide) { create(:guide, teacher_info: '**foo**') }
-      it { expect(subject[:teacher_info]).to eq("<p><strong>foo</strong></p>\n") }
-    end
-    context 'exercises' do
-      let(:guide) { create(:guide, exercises: [exercise]) }
-      subject { guide.to_markdownified_resource_h[:exercises].first }
-
-      context 'description' do
-        let(:exercise) { build(:exercise, description: '`foo = (+)`') }
-        it { expect(subject[:description]).to eq("<p><code>foo = (+)</code></p>\n") }
-      end
-      context 'corollary' do
-        let(:exercise) { build(:exercise, corollary: '[Google](https://google.com)') }
-        it { expect(subject[:corollary]).to eq("<p><a title=\"\" href=\"https://google.com\" target=\"_blank\">Google</a></p>\n") }
-      end
-      context 'teacher_info' do
-        let(:exercise) { build(:exercise, teacher_info: '**foo**') }
-        it { expect(subject[:teacher_info]).to eq("<p><strong>foo</strong></p>\n") }
-      end
-      context 'hint' do
-        let(:exercise) { build(:exercise, hint: '***foo***') }
-        it { expect(subject[:hint]).to eq("<p><strong><em>foo</em></strong></p>\n") }
-      end
-    end
-  end
-end

data/spec/models/interactive_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-describe Interactive, organization_workspace: :test do
-  let!(:interactive) { create(:interactive) }
-  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