mumuki-laboratory 7.9.2 → 7.10.0

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-7082a83493eb/spec/models/gamified_spec.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-describe Gamified, organization_workspace: :test do
-  let(:student) { create(:user) }
-  let(:exercise) { create(:indexed_exercise) }
-  let(:assignment) { create(:assignment, submitter: student, exercise: exercise)}
-  let(:exp) { UserStats.exp_for(student) }
-
-  let(:evaluation) { double Mumuki::Domain::Evaluation::Automated }
-
-  before do
-    allow(Mumuki::Domain::Evaluation::Automated).to receive(:new).and_return(evaluation)
-  end
-
-  def submit_on!(exercise, status)
-    allow(evaluation).to receive(:evaluate!).and_return({ status: status })
-    exercise.submit_solution!(student)
-  end
-
-  describe '#award_experience_points!' do
-    context 'no solutions sent' do
-      it 'has no experience points for that user' do
-        expect(exp).to eq 0
-      end
-    end
-
-    context 'solutions sent on one exercise' do
-      context 'failed' do
-        before { submit_on!(exercise, :failed) }
-
-        it 'does not award points' do
-          expect(exp).to eq 0
-        end
-      end
-
-      context 'passed_with_warnings' do
-        before { submit_on!(exercise, :passed_with_warnings) }
-
-        it 'awards points' do
-          expect(exp).to eq Mumuki::Domain::Status::Submission::PassedWithWarnings.exp_given
-        end
-
-        it 'does not take points away if errored afterwards' do
-          submit_on!(exercise, :errored)
-
-          expect(exp).to eq Mumuki::Domain::Status::Submission::PassedWithWarnings.exp_given
-        end
-      end
-
-      context 'passed' do
-        before { submit_on!(exercise, :passed) }
-
-        it 'awards points if passed once' do
-          expect(exp).to eq Mumuki::Domain::Status::Submission::Passed.exp_given
-        end
-
-        it 'awards same amount of points if passed multiple times' do
-          3.times { submit_on!(exercise, :passed) }
-
-          expect(exp).to eq Mumuki::Domain::Status::Submission::Passed.exp_given
-        end
-
-        it 'does not take points away if failed afterwards' do
-          submit_on!(exercise, :failed)
-
-          expect(exp).to eq Mumuki::Domain::Status::Submission::Passed.exp_given
-        end
-      end
-
-      context 'gradually improving' do
-        before do
-          submit_on!(exercise, :failed)
-          submit_on!(exercise, :passed_with_warnings)
-          submit_on!(exercise, :passed)
-        end
-
-        it 'awards max points once' do
-          expect(exp).to eq Mumuki::Domain::Status::Submission::Passed.exp_given
-        end
-      end
-    end
-
-    context 'solutions sent on many exercises' do
-      let(:another_exercise) { create(:indexed_exercise) }
-      let(:one_more_exercise) { create(:indexed_exercise) }
-
-      before do
-        submit_on!(exercise, :passed)
-        submit_on!(another_exercise, :passed)
-        submit_on!(one_more_exercise, :passed)
-      end
-
-      it 'adds up experience' do
-        expect(exp).to eq Mumuki::Domain::Status::Submission::Passed.exp_given * 3
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-7082a83493eb/spec/models/guide_import_spec.rb

@@ -1,317 +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
-
-      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.6.0/bundler/gems/mumuki-domain-7082a83493eb/spec/models/guide_spec.rb

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