mumuki-laboratory 7.9.2 → 7.10.0

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Mumuki::Domain::Submission::Query do
-  let!(:exercise) { create(:exercise) }
-  let(:user) { create(:user) }
-
-  before do
-    expect_any_instance_of(Challenge).to receive(:automated_evaluation_class).and_return(Mumuki::Domain::Evaluation::Automated)
-    allow_any_instance_of(Language).to receive(:run_query!).and_return(status: :passed, result: '5')
-  end
-
-  describe '#submit_query!', organization_workspace: :test do
-    let!(:results) { exercise.submit_query!(user, query: 'foo', content: 'bar', cookie: ['foo', 'bar']) }
-    let(:assignment) { exercise.find_assignment_for(user, Organization.current) }
-
-    it { expect(results[:status]).to eq :passed }
-    it { expect(results[:result]).to eq '5' }
-    it { expect(assignment.solution).to eq 'bar' }
-    it { expect(assignment.status).to eq :pending }
-  end
-end

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

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe Mumuki::Domain::Submission::Query, organization_workspace: :test do
-  let!(:exercise) { create(:problem) }
-  let(:student) { create(:user) }
-
-  describe '#submit_question!' do
-    let(:assignment) { exercise.find_assignment_for(student, Organization.current) }
-
-    context 'when just a question on an empty assignment is sent' do
-      before { exercise.submit_question!(student, content: 'Please help!') }
-
-      it { expect(assignment.status).to eq :pending }
-      it { expect(assignment.result).to be nil }
-
-      it { expect(assignment.solution).to be nil }
-      it { expect(assignment.messages.count).to eq 1 }
-      it { expect(assignment.submission_id).to_not be nil }
-    end
-
-    context 'when a question on a previous submission is sent' do
-      before do
-        assignment = exercise.submit_solution!(student, content: 'x = 1')
-        assignment.failed!
-        @original_submission_id = assignment.submission_id
-      end
-
-      before { exercise.submit_question!(student, content: 'Please help!') }
-
-      it { expect(assignment.status).to eq :failed }
-      it { expect(assignment.result).to eq 'noop result' }
-      it { expect(assignment.solution).to eq 'x = 1' }
-      it { expect(assignment.messages.count).to eq 1 }
-      it { expect(assignment.submission_id).to eq @original_submission_id }
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe Reading, organization_workspace: :test do
-  let(:guide) { create(:indexed_guide) }
-  let!(:reading) { create(:reading, guide: guide) }
-  let!(:user) { create(:user) }
-
-  let!(:result) { reading.submit_confirmation!(user) }
-
-  it { expect(result).to eq status: :passed, result: '' }
-end

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

@@ -1,142 +0,0 @@
-require 'spec_helper'
-
-describe Mumuki::Domain::Submission::Solution, organization_workspace: :test do
-
-  let(:user) { create(:user) }
-
-  describe '#try_submit_solution!' do
-
-    context 'when on chapter' do
-      let(:problem) { create(:problem) }
-      let!(:chapter) {
-        create(:chapter, name: 'Functional Programming', lessons: [
-          create(:lesson, exercises: [problem])
-        ]) }
-
-      before { reindex_current_organization! }
-      let!(:result) { problem.try_submit_solution! user }
-
-      it { expect(result).to eq problem.find_assignment_for(user, Organization.current) }
-      it { expect(result.attempts_left).to eq nil }
-      it { expect(result.attempts_left?).to be true }
-    end
-
-    context 'when on exam' do
-      let(:problem) { create(:problem) }
-      let!(:exam) { create(:exam, max_problem_submissions: 10, exercises: [problem]) }
-
-      before { reindex_current_organization! }
-      let(:result) { problem.try_submit_solution! user }
-
-      it { expect(result).to eq problem.find_assignment_for(user, Organization.current) }
-      it { expect(result.attempts_left).to eq 9 }
-      it { expect(result.attempts_left?).to be true }
-    end
-  end
-
-  describe '#submit_solution!' do
-
-    before { expect_any_instance_of(Challenge).to receive(:automated_evaluation_class).and_return(Mumuki::Domain::Evaluation::Automated) }
-    before { expect_any_instance_of(Language).to receive(:run_tests!).with(bridge_request).and_return(bridge_response) }
-    let(:submission_attributes) { {} }
-    let(:assignment) { exercise.submit_solution! user, submission_attributes }
-
-    context 'when results have no expectation' do
-      let(:exercise) { create(:indexed_exercise) }
-      let(:bridge_request) do
-        {
-          content: nil,
-          custom_expectations: "\n",
-          expectations: [],
-          extra: "",
-          locale: "en",
-          settings: {},
-          test: "dont care"
-        }
-      end
-      let(:bridge_response) { {result: '0 failures', status: :passed} }
-
-      it { expect(assignment.status).to eq(:passed) }
-      it { expect(assignment.result).to include('0 failures') }
-    end
-
-    context 'when submissions has client result' do
-      let(:exercise) { create(:indexed_exercise) }
-      let(:bridge_request) do
-        {
-          content: 'x = 2',
-          custom_expectations: "\n",
-          expectations: [],
-          extra: "",
-          locale: "en",
-          settings: {},
-          test: "dont care",
-          client_result: {
-            status: :passed,
-            test_results: [{title: 'true is true', status: :passed, result: ''}]
-          }
-        }
-      end
-      let(:bridge_response) { {result: '0 failures', status: :passed} }
-      let(:submission_attributes) do
-        {
-          content: 'x = 2',
-          client_result: {
-            status: :passed,
-            test_results: [{title: 'true is true', status: :passed, result: ''}]
-          }
-        }
-      end
-
-      it { expect(assignment.status).to eq(:passed) }
-      it { expect(assignment.result).to include('0 failures') }
-    end
-
-    context 'when results have standard expectations' do
-      let(:exercise) {
-        create(:indexed_exercise, expectations: [{binding: :foo, inspection: :HasComposition}]) }
-      let(:bridge_request) do
-        {
-          content: nil,
-          custom_expectations: "\n",
-          expectations: [{"binding"=>:foo, "inspection"=>:HasComposition}],
-          extra: "",
-          locale: "en",
-          settings: {},
-          test: "dont care"
-        }
-      end
-      let(:bridge_response) { {
-          result: '0 failures',
-          status: :passed,
-          expectation_results: [binding: 'foo', inspection: 'HasBinding', result: :passed]} }
-
-      it { expect(assignment.status).to eq(:passed) }
-      it { expect(assignment.result).to include('0 failures') }
-      it { expect(assignment.expectation_results).to eq([{binding: 'foo', inspection: 'HasBinding', result: :passed}]) }
-    end
-
-    context 'when results have custom expectations' do
-      let(:exercise) { create(:indexed_exercise, custom_expectations: 'expectation "foo uses composition": `foo` uses composition;') }
-      let(:bridge_request) do
-        {
-          content: nil,
-          custom_expectations: "expectation \"foo uses composition\": `foo` uses composition;\n",
-          expectations: [],
-          extra: "",
-          locale: "en",
-          settings: {},
-          test: "dont care"
-        }
-      end
-      let(:bridge_response) { {
-          result: '0 failures',
-          status: :passed,
-          expectation_results: [binding: '<<custom>>', inspection: 'foo uses composition', result: :passed]} }
-
-      it { expect(assignment.status).to eq(:passed) }
-      it { expect(assignment.result).to include('0 failures') }
-      it { expect(assignment.expectation_results).to eq([binding: '<<custom>>', inspection: 'foo uses composition', result: :passed]) }
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Stats do
-  context 'when someone has not started' do
-    let(:stats) { Stats.new(passed: 0, passed_with_warnings: 0, failed: 0, pending: 10, skipped: 0) }
-    it { expect(stats.submitted).to eq 0 }
-    it { expect(stats.done?).to be false }
-    it { expect(stats.started?).to be false }
-  end
-
-  context 'when someone has started but is not done' do
-    let(:stats) { Stats.new(passed: 3, passed_with_warnings: 2, failed: 1, pending: 3, skipped: 1) }
-    it { expect(stats.submitted).to eq 6 }
-    it { expect(stats.done?).to be false }
-    it { expect(stats.started?).to be true }
-  end
-
-  context 'when someone is done' do
-    let(:stats) { Stats.new(passed: 7, passed_with_warnings: 2, failed: 0, pending: 0, skipped: 1) }
-    it { expect(stats.submitted).to eq 9 }
-    it { expect(stats.done?).to be true }
-    it { expect(stats.started?).to be true }
-  end
-end

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

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe Mumuki::Domain::Status do
-  describe 'discussion' do
-    it { expect(Mumuki::Domain::Status::Discussion::PendingReview.as_json).to eq 'pending_review' }
-  end
-
-  describe 'discussion' do
-    it { expect(Mumuki::Domain::Status::Submission::PassedWithWarnings.as_json).to eq 'passed_with_warnings' }
-  end
-end

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

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe String do
-  describe 'markdown_paragraphs' do
-    it { expect("hello\nworld !\n\nbye bye".markdown_paragraphs).to eq ["hello\nworld !", 'bye bye'] }
-    it { expect("hello\nworld !\n \nbye bye".markdown_paragraphs).to eq ["hello\nworld !", 'bye bye'] }
-    it { expect("hello\nworld !\n \n\nbye bye".markdown_paragraphs).to eq ["hello\nworld !", 'bye bye'] }
-  end
-end

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

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe Mumuki::Domain::Status::Submission do
-  let(:submission) { Mumuki::Domain::Status::Submission }
-
-  let(:aborted)                   { submission::Aborted }
-  let(:errored)                   { submission::Errored }
-  let(:failed)                    { submission::Failed }
-  let(:manual_evaluation_pending) { submission::ManualEvaluationPending }
-  let(:passed)                    { submission::Passed }
-  let(:passed_with_warnings)      { submission::PassedWithWarnings }
-  let(:pending)                   { submission::Pending }
-  let(:running)                   { submission::Running }
-  let(:skipped)                   { submission::Skipped }
-
-  let(:statuses) { submission::STATUSES }
-  let(:exp_statuses) { [passed, passed_with_warnings, skipped] }
-  let(:no_exp_statuses) { statuses - exp_statuses }
-
-  describe 'aborted' do
-    it { expect(aborted.exp_given).to be 0 }
-    it { expect(   exp_statuses.all? { |status| aborted.improved_by?(status) }).to be true  }
-    it { expect(no_exp_statuses.all? { |status| aborted.improved_by?(status) }).to be false }
-  end
-
-  describe 'errored' do
-    it { expect(errored.exp_given).to be 0 }
-    it { expect(   exp_statuses.all? { |status| errored.improved_by?(status) }).to be true  }
-    it { expect(no_exp_statuses.all? { |status| errored.improved_by?(status) }).to be false }
-  end
-
-  describe 'failed' do
-    it { expect(failed.exp_given).to be 0 }
-    it { expect(   exp_statuses.all? { |status| failed.improved_by?(status) }).to be true  }
-    it { expect(no_exp_statuses.all? { |status| failed.improved_by?(status) }).to be false }
-  end
-
-  describe 'manual_evaluation_pending' do
-    it { expect(manual_evaluation_pending.exp_given).to be 0 }
-    it { expect(   exp_statuses.all? { |status| manual_evaluation_pending.improved_by?(status) }).to be true  }
-    it { expect(no_exp_statuses.all? { |status| manual_evaluation_pending.improved_by?(status) }).to be false }
-  end
-
-  describe 'passed' do
-    it { expect(passed.exp_given).to be 100 }
-    it { expect(statuses.all? { |status| passed.improved_by?(status) }).to be false }
-  end
-
-  describe 'passed_with_warnings' do
-    let(:solved_statuses) { exp_statuses - [passed_with_warnings] }
-
-    it { expect(passed_with_warnings.exp_given).to be 50 }
-    it { expect(solved_statuses.all? { |status| passed_with_warnings.improved_by?(status) }).to be true }
-    it { expect(no_exp_statuses.all? { |status| passed_with_warnings.improved_by?(status) }).to be false }
-  end
-
-  describe 'pending' do
-    it { expect(pending.exp_given).to be 0 }
-    it { expect(   exp_statuses.all? { |status| pending.improved_by?(status) }).to be true  }
-    it { expect(no_exp_statuses.all? { |status| pending.improved_by?(status) }).to be false }
-  end
-
-  describe 'running' do
-    it { expect(running.exp_given).to be 0 }
-    it { expect(   exp_statuses.all? { |status| running.improved_by?(status) }).to be true  }
-    it { expect(no_exp_statuses.all? { |status| running.improved_by?(status) }).to be false }
-  end
-
-  describe 'skipped' do
-    it { expect(skipped.exp_given).to be 100 }
-    it { expect(statuses.all? { |status| skipped.improved_by?(status) }).to be false }
-  end
-end

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

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe Topic do
-  describe 'transparent navigation api' do
-    let!(:topic) { create(:topic, slug: 'foo/bar') }
-    let(:params) { { organization: 'foo', repository: 'bar' } }
-
-    it { expect(topic.transparent_id).to eq 'foo/bar' }
-    it { expect(topic.transparent_params).to eq params }
-    it { expect(Topic.find_transparently!(params)).to eq topic }
-  end
-
-  describe 'slug normalization' do
-    let(:topic) { create(:topic, slug: 'fLbUlGaReLlI/MuMUkI-saMPle-gUIde') }
-
-    it { expect(topic.slug).to eq('flbulgarelli/mumuki-sample-guide') }
-  end
-
-  describe '#import_from_resource_h!' do
-    let!(:haskell) { create(:haskell) }
-    let!(:gobstones) { create(:gobstones) }
-
-    let!(:lesson_1) { create(:lesson, name: 'l1') }
-    let(:guide_1) { lesson_1.guide }
-
-    let!(:lesson_2) { create(:lesson, name: 'l2') }
-
-    let!(:guide_2) { create(:guide, name: 'g2') }
-    let!(:guide_3) { create(:guide, name: 'g3') }
-
-    let(:topic_resource_h) do
-      {name: 'sample topic',
-       description: 'topic description',
-       slug: 'mumuki/mumuki-sample-topic',
-       locale: 'en',
-       lessons: [guide_2, guide_1, guide_3].map(&:slug)}
-    end
-
-    context 'when guide is empty' do
-      let(:topic) { create(:topic, lessons: [lesson_1, lesson_2]) }
-
-      before do
-        topic.import_from_resource_h!(topic_resource_h)
-      end
-
-      it { expect(topic.name).to eq 'sample topic' }
-      it { expect(topic.description).to eq 'topic description' }
-      it { expect(topic.locale).to eq 'en' }
-      it { expect(topic.lessons.count).to eq 3 }
-      it { expect(topic.lessons.first.guide).to eq guide_2 }
-      it { expect(topic.lessons.second).to eq lesson_1 }
-      it { expect(topic.lessons.third.guide).to eq guide_3 }
-      it { expect(Guide.count).to eq 4 }
-      it { expect(Lesson.count).to eq 3 }
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe Usage do
-
-  let!(:fundamentals) { create(:topic) }
-  let!(:functional_programming) { create(:topic) }
-  let!(:oop) { create(:topic) }
-  let!(:logic_programming) { create(:topic) }
-
-  let!(:programming) { create(:book, chapters: [
-      build(:chapter, topic: fundamentals),
-      build(:chapter, topic: functional_programming),
-      build(:chapter, topic: oop),
-      build(:chapter, topic: logic_programming),
-  ]) }
-
-  let!(:paradigms) { create(:book, chapters: [
-      build(:chapter, topic: functional_programming),
-      build(:chapter, topic: logic_programming),
-      build(:chapter, topic: oop),
-  ]) }
-
-  let!(:central) { create(:organization, name: 'central', book: programming) }
-  let!(:pdep) { create(:organization, name: 'pdep', book: paradigms) }
-
-  shared_examples_for 'something that does not interfere with normal scopes' do
-    it 'does not affect all-scope' do
-      expect(Topic.all.count).to eq 4
-      expect(Chapter.all.count).to eq 7
-      expect(Book.all.count).to eq 2
-      expect(Organization.all.count).to eq 2
-    end
-  end
-
-  context 'on central' do
-    before { central.switch! }
-
-    it_behaves_like 'something that does not interfere with normal scopes'
-
-    it { expect(central.book).to eq programming }
-
-    it { expect(programming.chapters.count).to eq 4 }
-    it { expect(programming.chapters.map(&:topic)).to eq [fundamentals, functional_programming, oop, logic_programming] }
-
-    it 'usage_in_organization behaves properly' do
-      expect(fundamentals.usage_in_organization).to_not be_nil
-      expect(fundamentals.usage_in_organization.number).to eq 1
-
-      expect(functional_programming.usage_in_organization).to_not be_nil
-      expect(functional_programming.usage_in_organization).to be_a(Chapter)
-      expect(functional_programming.usage_in_organization.number).to eq 2
-      expect(oop.usage_in_organization.number).to eq 3
-      expect(logic_programming.usage_in_organization.number).to eq 4
-    end
-
-    it { expect(Usage.in_organization.count).to eq 5  }
-
-  end
-
-  context 'on pdep' do
-    before { pdep.switch! }
-
-    it_behaves_like 'something that does not interfere with normal scopes'
-
-    it { expect(pdep.book).to eq paradigms }
-
-    it { expect(paradigms.chapters.count).to eq 3 }
-    it { expect(paradigms.chapters.map(&:topic)).to eq [functional_programming, logic_programming, oop] }
-
-    it 'usage_in_organization behaves properly' do
-      expect(fundamentals.usage_in_organization).to be_nil
-
-      expect(functional_programming.usage_in_organization).to_not be_nil
-      expect(functional_programming.usage_in_organization).to be_a(Chapter)
-      expect(functional_programming.usage_in_organization.number).to eq 1
-      expect(logic_programming.usage_in_organization.number).to eq 2
-      expect(oop.usage_in_organization.number).to eq 3
-    end
-
-    it { expect(Usage.in_organization.count).to eq 4  }
-  end
-end