mumuki-laboratory 7.0.10 → 7.0.11

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/organization_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe Organization, organization_workspace: :test do
+  let(:user) { create(:user) }
+  let(:central) { create(:organization, name: 'central') }
+
+  describe '.import_from_resource_h!' do
+    let(:book) { create(:book) }
+    let(:resource_h) { {
+      name: 'zulema',
+      book: book.slug,
+      profile: { locale: 'es', contact_email: 'contact@email.com' }
+    } }
+    let!(:imported) { Organization.import_from_resource_h! resource_h }
+    let(:found) { Organization.find_by(name: 'zulema').to_resource_h }
+
+    it { expect(imported).to_not be nil }
+    it { expect(found).to json_eq resource_h, except: [:theme, :settings]  }
+  end
+
+  describe '#ask_for_help_enabled?' do
+    let(:user) { create(:user) }
+    let(:organization) { create(:organization) }
+
+    context 'when non assistance medium present' do
+      it { expect(organization.ask_for_help_enabled? user).to be false }
+      it { expect(organization.ask_for_help_enabled?).to be false }
+    end
+
+    context 'when can report issues' do
+      before { organization.report_issue_enabled = true }
+      it { expect(organization.ask_for_help_enabled? user).to be true }
+      it { expect(organization.ask_for_help_enabled?).to be true }
+    end
+    context 'when there is a community link' do
+      before { organization.community_link = 'https://an-external-mumuki-forum.org' }
+      it { expect(organization.ask_for_help_enabled? user).to be true }
+      it { expect(organization.ask_for_help_enabled?).to be true }
+    end
+
+    context 'when forum is enabled' do
+      before { organization.forum_enabled = true }
+
+      context 'when user does not meet minimal permissions' do
+        it { expect(organization.ask_for_help_enabled? user).to be false }
+        it { expect(organization.ask_for_help_enabled?).to be true }
+      end
+
+      context 'when user meets minimal permissions' do
+        before { user.make_student_of! organization.slug }
+        it { expect(organization.ask_for_help_enabled? user).to be true }
+        it { expect(organization.ask_for_help_enabled?).to be true }
+      end
+    end
+  end
+
+  describe '.current' do
+    let(:organization) { Organization.find_by(name: 'test') }
+    it { expect(organization).to_not be nil }
+    it { expect(organization).to eq Organization.current }
+  end
+
+  describe 'defaults' do
+    let(:fresh_organization) { create(:organization, name: 'bar') }
+
+    context 'no base organization' do
+      it { expect(fresh_organization.settings.customized_login_methods?).to be true }
+      it { expect(fresh_organization.theme_stylesheet).to eq nil }
+    end
+
+    context 'with base organization' do
+      before { create(:base, theme_stylesheet: '.foo { width: 100%; }') }
+
+      it { expect(fresh_organization.settings.customized_login_methods?).to be true }
+      it { expect(fresh_organization.theme_stylesheet).to eq '.foo { width: 100%; }' }
+    end
+  end
+
+  describe '#notify_recent_assignments!' do
+    it { expect { Organization.current.notify_recent_assignments! 1.minute.ago }.to_not raise_error }
+  end
+
+  describe 'restricter_login_methods?' do
+    let(:private_organization) { create(:private_organization, name: 'digitaldojo') }
+    let(:public_organization) { create(:public_organization, name: 'guolok') }
+
+    it { expect(private_organization.settings.customized_login_methods?).to be true }
+    it { expect(private_organization.private?).to be true }
+
+    it { expect { private_organization.update! public: true }.to raise_error('Validation failed: A public organization can not restrict login methods') }
+
+    it { expect(public_organization.settings.customized_login_methods?).to be false }
+    it { expect(public_organization.private?).to be false }
+  end
+
+  describe '#notify_assignments_by!' do
+    it { expect { Organization.current.notify_assignments_by! user }.to_not raise_error }
+  end
+
+  describe '#in_path?' do
+    let(:organization) { Organization.current }
+    let!(:chapter_in_path) { create(:chapter, lessons: [
+      create(:lesson, exercises: [
+        create(:exercise),
+        create(:exercise)
+      ]),
+      create(:lesson)
+    ]) }
+    let(:topic_in_path) { chapter_in_path.lessons.first }
+    let(:topic_in_path) { chapter_in_path.topic }
+    let(:lesson_in_path) { chapter_in_path.lessons.first }
+    let(:guide_in_path) { lesson_in_path.guide }
+    let(:exercise_in_path) { lesson_in_path.exercises.first }
+
+    let!(:orphan_exercise) { create(:exercise) }
+    let!(:orphan_guide) { orphan_exercise.guide }
+
+    before { reindex_current_organization! }
+
+    it 'build path properly' do
+      expect(organization.in_path? orphan_guide).to be false
+      expect(organization.in_path? orphan_exercise).to be false
+
+      expect(organization.in_path? chapter_in_path).to be true
+      expect(organization.in_path? topic_in_path).to be true
+      expect(organization.in_path? lesson_in_path).to be true
+      expect(organization.in_path? guide_in_path).to be true
+    end
+  end
+
+  describe 'login_settings' do
+    let(:fresh_organization) { create(:organization, name: 'foo') }
+    it { expect(fresh_organization.login_settings.login_methods).to eq Mumukit::Login::Settings.default_methods }
+    it { expect(fresh_organization.login_settings.social_login_methods).to eq [] }
+  end
+
+  describe 'validations' do
+    let(:book) { create :book }
+
+    context 'is valid when all is ok' do
+      let(:organization) { build :public_organization }
+      it { expect(organization.valid?).to be true }
+    end
+
+    context 'is invalid when there are no books' do
+      let(:organization) { build :public_organization, book: nil }
+      it { expect(organization.valid?).to be false }
+    end
+
+    context 'is invalid when the locale isnt known' do
+      let(:organization) { build :public_organization, locale: 'uk-DA' }
+      it { expect(organization.valid?).to be false }
+    end
+
+    context 'has login method' do
+      let(:organization) { build :public_organization, login_methods: ['github'] }
+      it { expect(organization.has_login_method? 'github').to be true }
+      it { expect(organization.has_login_method? 'google').to be false }
+    end
+  end
+
+  describe 'in_path' do
+    let(:organization) { create :public_organization, name: 'main' }
+    let!(:other_organization) { create :public_organization, name: 'other' }
+    before { create :public_organization, name: 'other-more' }
+
+    it 'is a relation' do
+      expect(Organization.in_path Guide.new).to be_a ActiveRecord::Relation
+    end
+
+    context 'with a topic usage' do
+      let(:chapter) { create(:chapter) }
+
+      before { chapter.index_usage! organization }
+
+      it { expect(Organization.in_path(chapter.topic).map(&:name)).to eq ['main'] }
+      it { expect(organization.in_path? chapter.topic).to be true }
+    end
+
+    context 'with a guide usage' do
+      let(:lesson) { create(:lesson) }
+
+      before { lesson.index_usage! organization }
+
+      it { expect(Organization.in_path(lesson.guide).map(&:name)).to eq ['main'] }
+      it { expect(organization.in_path? lesson.guide).to be true }
+    end
+
+    context 'with a guide and topic usage with same id' do
+      let(:chapter) { create(:chapter, topic: create(:topic, id: 3141516)) }
+      let(:lesson) { create(:lesson, guide: create(:guide, id: 3141516)) }
+
+      before { lesson.index_usage! organization }
+      before { chapter.index_usage! other_organization }
+
+      it { expect(Organization.in_path(lesson.guide).map(&:name)).to eq ['main'] }
+      it { expect(Organization.in_path(chapter.topic).map(&:name)).to eq ['other'] }
+    end
+
+    context 'with a book usage' do
+      let(:book) { create(:book) }
+
+      before { book.index_usage! organization }
+
+      it { expect(Organization.in_path(book).map(&:name)).to eq ['main'] }
+      it { expect(organization.in_path? book).to be true }
+    end
+  end
+
+  describe '#description_html' do
+    let(:organization) { build(:organization, description: 'some text with *markdown*!') }
+
+    it { expect(organization.description_html).to eq("<p>some text with <em>markdown</em>!</p>\n") }
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/playground_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Playground do
+  let(:user) { create(:user) }
+
+  describe '#create' do
+    context 'when language is queriable and exercise is playable' do
+      let(:language) { create(:language, queriable: true) }
+      let(:guide) { create(:guide) }
+      let(:exercise) { build(:playground, language: language, layout: :input_bottom, guide: guide, number: 1) }
+
+      it { expect(exercise.save).to be true }
+    end
+
+    context 'when language is not queriable and exercise is playable' do
+      let(:language) { create(:language, queriable: false) }
+      let(:exercise) { build(:playground, language: language, layout: :input_bottom) }
+
+      it { expect(exercise.save).to be false }
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/problem_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Problem, organization_workspace: :test do
+
+  context 'when no manual evaluation and' do
+    before { problem.manual_evaluation = false }
+
+    context 'when no test nor expectations' do
+      let(:problem) { build(:problem, test: nil, expectations: []) }
+      it { expect(problem.evaluation_criteria?).to be false }
+    end
+
+    context 'when no test but expectations' do
+      let(:problem) { build(:problem, test: nil, expectations: [{inspection: 'HasBinding', binding: 'foo'}]) }
+      it { expect(problem.evaluation_criteria?).to be true }
+    end
+
+    context 'when no test but custom expectations' do
+      let(:problem) { build(:problem, test: nil, custom_expectations: 'expectation: uses `foo`') }
+      it { expect(problem.evaluation_criteria?).to be true }
+    end
+
+    context 'when no expectations but test' do
+      let(:problem) { build(:problem, test: 'describe ...', expectations: []) }
+      it { expect(problem.evaluation_criteria?).to be true }
+    end
+  end
+
+  context 'when is manual evaluation and' do
+    before { problem.manual_evaluation = true }
+
+    context 'when no test nor expectations' do
+      let(:problem) { build(:problem, test: nil, expectations: []) }
+      it { expect(problem.evaluation_criteria?).to be true }
+    end
+
+  end
+
+  context 'when solving then failing' do
+    let!(:problem) { create(:problem) }
+    let!(:user) { create(:user) }
+
+    before do
+      assignment = problem.submit_solution!(user, content: 'foo')
+
+      assignment.test_results = [{title: 'foo', result: '', status: :passed}]
+      assignment.expectation_results = [{result: :passed, binding: 'foo', inspection: 'HasBinding'}]
+      assignment.status = :passed
+      assignment.save!
+
+      @assignment = problem.submit_solution!(user, content: 'bar')
+    end
+
+    it { expect(@assignment.expectation_results).to eq [] }
+    it { expect(@assignment.test_results).to eq nil }
+    it { expect(@assignment.result).to eq 'noop result' }
+    it { expect(@assignment.status).to eq :failed }
+  end
+
+  context 'when submit exercise with blank utf8 chars' do
+    let!(:problem) { create(:problem) }
+    let!(:user) { create(:user) }
+
+    before do
+      @assignment = problem.submit_solution!(user, content: "program {\n  Poner(Norte)\n}")
+    end #                                                                ▲
+    #                                                                    ╰ Blank unsupported UTF-8 char
+    it { expect(@assignment.solution).to eq "program {\n  Poner(Norte)\n}" }
+    #                                                    ▲
+    #                                                    ╰ Normalized text / No blank UTF-8 char
+  end
+
+  context 'when submit exercise with non blank utf8 chars' do
+    let!(:problem) { create(:problem) }
+    let!(:user) { create(:user) }
+
+    before do
+      @assignment = problem.submit_solution!(user, content: "semáforo")
+    end
+
+    it { expect(@assignment.solution).to eq "semáforo" }
+
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/query_spec.rb

@@ -0,0 +1,21 @@
+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.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/question_spec.rb

@@ -0,0 +1,37 @@
+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.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/reading_spec.rb

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

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/spec/models/solution_spec.rb

@@ -0,0 +1,77 @@
+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!).and_return(bridge_response) }
+    let(:assignment) { exercise.submit_solution! user }
+
+    context 'when results have no expectation' do
+      let(:exercise) { create(:exercise) }
+      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 results have standard expectations' do
+      let(:exercise) {
+        create(:exercise, expectations: [{binding: :foo, inspection: :HasComposition}]) }
+      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(:exercise, custom_expectations: 'expectation "foo uses composition": `foo` uses composition;') }
+      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