mumuki-laboratory 7.3.1 → 7.5.1

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/spec/models/guide_import_spec.rb

@@ -0,0 +1,317 @@
+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
+
+      it 'is removed from the guide' do
+        expect(guide.exercises.count).to eq 5
+        expect(guide.exercises).not_to include exercise_6
+      end
+
+      it 'is deleted from the database' do
+        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 'imports basic fields' do
+        expect(guide).to_not be nil
+        expect(guide.name).to eq 'sample guide'
+        expect(guide.language).to eq haskell
+        expect(guide.slug).to eq 'mumuki/sample-guide'
+        expect(guide.extra).to eq 'bar'
+        expect(guide.description).to eq 'Baz'
+      end
+
+      it 'imports first exercise' do
+        expect(guide.exercises.count).to eq 5
+        expect(guide.exercises.first.language).to eq gobstones
+        expect(guide.exercises.first.extra_visible).to be false
+        expect(guide.exercises.first.assistance_rules).to be_present
+        expect(guide.exercises.first.assistant.rules.count).to eq 2
+      end
+
+      it 'imports second exercise' do
+        expect(guide.exercises.second.language).to eq haskell
+        expect(guide.exercises.second.default_content).to eq 'a default content'
+        expect(guide.exercises.second.extra_visible).to be true
+      end
+
+      it { expect(guide.exercises.third.expectations.first['binding']).to eq 'foo' }
+
+      it 'imports fourth exercise' do
+        expect(guide.exercises.fourth.choices).to eq [{'value' => 'foo', 'checked' => false}, {'value' => 'bar', 'checked' => true}]
+        expect(guide.exercises.fourth.choice_values).to eq ['foo', 'bar']
+      end
+
+      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') }
+
+        it 'exercises are not duplicated' do
+          expect(guide.exercises.count).to eq 5
+          expect(Exercise.count).to eq 5
+        end
+
+        it 'changes type properly' do
+          expect(guide.exercises.first).to be_instance_of(Problem)
+          expect(guide.exercises.first).to eq reloaded_exercise_1
+        end
+      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] }
+
+        it 'exercises are not duplicated' do
+          expect(guide.exercises.count).to eq 5
+          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
+
+      it 'exercises are not duplicated' do
+        expect(guide.exercises.count).to eq 5
+        expect(Exercise.count).to eq 5
+      end
+
+      it 'load types properly' do
+        expect(guide.exercises.first).to be_instance_of(Problem)
+        expect(guide.exercises.second).to be_instance_of(Playground)
+        expect(guide.exercises.third).to be_instance_of(Problem)
+      end
+
+      it 'loads exercises properly' do
+        expect(guide.exercises.second).to eq reloaded_exercise_2
+        expect(guide.exercises.third).to eq reloaded_exercise_1
+      end
+
+      it 'loads exercises order properly' do
+        expect(guide.exercises.first.number).to eq 1
+        expect(guide.exercises.second.number).to eq 2
+        expect(guide.exercises.third.number).to eq 3
+        expect(guide.exercises.fourth.number).to eq 4
+      end
+
+      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 custom expectations' 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',
+              custom_expectations: 'expect: assigns;',
+              id: 2}]}
+      end
+
+      before do
+        guide.import_from_resource_h! guide_resource_h
+      end
+
+      it 'load expectations properly' do
+        expect(guide.exercises.first.custom_expectations).to eq "expect: assigns;\n"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-a059418e5fd8/spec/models/guide_spec.rb

@@ -0,0 +1,264 @@
+require 'spec_helper'
+
+describe Guide do
+  let!(:extra_user) { create(:user, first_name: 'Ignatius', last_name: 'Reilly') }
+  let(:guide) { create(:guide) }
+
+  describe("schema fields are in sync") do
+    let(:resource_h_fields) { Guide.new(language: Language.new).to_expanded_resource_h.keys - [:exercises]}
+    let(:schema_fields) { Mumuki::Domain::Store::Github::GuideSchema.fields.map(&:reverse_name) - [:id, :exercises] }
+
+    it { expect(resource_h_fields).to contain_exactly(*schema_fields) }
+  end
+
+  describe 'slug normalization' do
+    let(:guide) { create(:guide, slug: 'fLbUlGaReLlI/MuMUkI-saMPle-gUIde') }
+
+    it { expect(guide.slug).to eq('flbulgarelli/mumuki-sample-guide') }
+  end
+
+  describe '#destroy' do
+    context 'when orphan' do
+      it { expect { guide.destroy! }.to_not raise_error }
+    end
+
+    context 'when referenced' do
+      before do
+        create(:chapter,
+          slug: 'mumuki/topic1',
+          lessons: [create(:lesson, guide: guide)])
+      end
+      it { expect { guide.destroy! }.to raise_error('Guide is still referenced') }
+    end
+
+    context 'when referenced' do
+      before do
+        create(:chapter,
+          slug: 'mumuki/topic1',
+          lessons: [create(:lesson, guide: guide)])
+      end
+      it { expect { guide.delete }.to raise_error('Guide is still referenced') }
+    end
+
+    context 'when used' do
+      let(:organization) do
+        create(:organization, book:
+          create(:book,
+            slug: 'mumuki/book',
+            chapters: [
+              create(:chapter,
+                slug: 'mumuki/topic1',
+                lessons: [create(:lesson, guide: guide)])]))
+      end
+      before { reindex_organization! organization }
+      it { expect { guide.reload.destroy! }.to raise_error('Guide is still in use in organization an-organization') }
+    end
+  end
+
+  describe '#clear_progress!' do
+    let(:an_exercise) { create(:exercise) }
+    let(:test_organization) { create(:test_organization) }
+
+    before do
+      test_organization.switch!
+      guide.exercises = [an_exercise]
+      an_exercise.submit_solution! extra_user
+    end
+
+    context 'when progress is exclusively in one organization' do
+      let(:another_exercise) { create(:exercise) }
+
+      before do
+        another_exercise.submit_solution! extra_user
+        guide.clear_progress!(extra_user, test_organization)
+      end
+
+      it 'destroys the guides assignments for the given user and organization' do
+        expect(an_exercise.find_assignment_for(extra_user, test_organization)).to be_nil
+      end
+
+      it 'does not destroy other guides assignments for the given user and organization' do
+        expect(another_exercise.find_assignment_for(extra_user, test_organization)).to be_truthy
+      end
+    end
+
+    context 'when progress is in more than one organization' do
+      let(:another_organization) { create(:another_test_organization) }
+
+      before do
+        another_organization.switch!
+        an_exercise.submit_solution! extra_user
+        guide.clear_progress!(extra_user, test_organization)
+      end
+
+      it 'destroys the guides assignments for the given user and organization' do
+        expect(an_exercise.find_assignment_for(extra_user, test_organization)).to be_nil
+      end
+    end
+  end
+
+  describe 'customizations' do
+    let!(:guide) {
+      create(:guide,
+        extra: 'guide extra',
+        expectations: [{binding: 'guide', inspection: 'Uses:expectations'}],
+        exercises: [exercise])}
+    let(:exercise) {
+      build(:exercise,
+        default_content: 'x = "$randomizedWord" /*...previousSolution...*/',
+        description: 'works with $randomizedWord',
+        extra: 'exercise extra',
+        hint: 'try $randomizedWord',
+        test: 'describe "$randomizedWord" do pending end',
+        randomizations: {
+          randomizedWord: { type: :one_of, value: %w(some) }
+        })}
+
+    it { expect(exercise.default_content).to eq 'x = "some" /*...previousSolution...*/' }
+    it { expect(exercise.description).to eq "works with some" }
+    it { expect(exercise.expectations).to eq guide.expectations }
+    it { expect(exercise.extra).to eq "guide extra\nexercise extra\n" }
+    it { expect(exercise.hint).to eq "try some" }
+    it { expect(exercise.test).to eq 'describe "some" do pending end' }
+
+    it { expect(exercise.to_resource_h).to json_eq({
+              default_content: 'x = "$randomizedWord" /*...previousSolution...*/',
+              description: 'works with $randomizedWord',
+              expectations: [],
+              extra: 'exercise extra',
+              hint: 'try $randomizedWord',
+              test: 'describe "$randomizedWord" do pending end'
+            },
+            only: Exercise::RANDOMIZED_FIELDS) }
+  end
+
+  describe '#to_resource_h' do
+    let(:guide) do
+      create :guide,
+            name: 'Introduction to Python',
+            slug: 'mumukiproject/python-guide',
+            description: 'Lets introduce python',
+            language: python,
+            exercises: [
+              create(:reading, name: 'This is python', language: python, bibliotheca_id: 10),
+              create(:problem, name: 'Say hello', language: python, bibliotheca_id: 11),
+              create(:playground, name: 'Some functions', language: python, bibliotheca_id: 12)
+            ]
+    end
+
+    let(:python) do
+      create :language, name: 'python', extension: 'py', test_extension: 'py'
+    end
+
+    it { expect(guide.to_resource_h).to json_eq beta: false,
+                                                expectations: [],
+                                                type: "learning",
+                                                id_format: "%05d",
+                                                private: false,
+                                                settings: {},
+                                                name: "Introduction to Python",
+                                                description: "Lets introduce python",
+                                                locale: "en",
+                                                slug: "mumukiproject/python-guide",
+                                                exercises: [ {
+                                                  name: "This is python",
+                                                  id: 10,
+                                                  locale: "en",
+                                                  layout: "input_bottom",
+                                                  tag_list: [],
+                                                  extra_visible: false,
+                                                  manual_evaluation: false,
+                                                  editor: 0,
+                                                  assistance_rules: [],
+                                                  randomizations: {},
+                                                  choices: [],
+                                                  type: "reading",
+                                                  settings: {},
+                                                  description: "Simple reading"
+                                                }, {
+                                                  name: "Say hello",
+                                                  id: 11,
+                                                  locale: "en",
+                                                  layout: "input_right",
+                                                  tag_list: [],
+                                                  extra_visible: false,
+                                                  manual_evaluation: false,
+                                                  editor: "code",
+                                                  assistance_rules: [],
+                                                  randomizations: {},
+                                                  choices: [],
+                                                  type: "problem",
+                                                  expectations: [],
+                                                  settings: {},
+                                                  description: "Simple problem",
+                                                  test: "dont care"
+                                                }, {
+                                                  name: "Some functions",
+                                                  id: 12,
+                                                  locale: "en",
+                                                  layout: "input_right",
+                                                  tag_list: [],
+                                                  extra_visible: false,
+                                                  manual_evaluation: false,
+                                                  editor: 0,
+                                                  assistance_rules: [],
+                                                  randomizations: {},
+                                                  choices: [],
+                                                  type: "playground",
+                                                  settings: {},
+                                                  description: "Simple playground"
+                                                }],
+                                                language: {
+                                                  name: "python",
+                                                  extension: 'py',
+                                                  test_extension: 'py'
+                                                }
+                                              }
+  end
+
+  describe 'transparent navigation api' do
+    let!(:guide) { create(:guide, slug: 'foo/bar') }
+    let(:params) { { organization: 'foo', repository: 'bar' } }
+
+    it { expect(guide.transparent_id).to eq 'foo/bar' }
+    it { expect(guide.transparent_params).to eq params }
+    it { expect(Guide.find_transparently!(params)).to eq guide }
+  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