mumuki-laboratory 6.1.5 → 6.2.0

data/spec/factories/api_client_factory.rb

@@ -1,18 +0,0 @@
-FactoryBot.define do
-  factory :api_client do |t|
-    transient do
-      role { :janitor }
-      grant { 'test/*' }
-    end
-
-    description { "foo" }
-    user {
-      create :user,
-             first_name: 'foo',
-             last_name: 'bar',
-             email: 'foo+1@bar.com',
-             uid: 'foo+1@bar.com',
-             permissions: { role => grant }
-      }
-  end
-end

data/spec/factories/assignments_factory.rb

@@ -1,7 +0,0 @@
-FactoryBot.define do
-  factory :assignment do
-    status { :pending }
-    exercise
-    submitter { create(:user) }
-  end
-end

data/spec/factories/book_factory.rb

@@ -1,7 +0,0 @@
-FactoryBot.define do
-  factory :book do
-    name { Faker::Lorem.sentence(3) }
-    description { Faker::Lorem.sentence(30) }
-    slug { "mumuki/mumuki-test-book-#{SecureRandom.uuid}" }
-  end
-end

data/spec/factories/chapter_factory.rb

@@ -1,16 +0,0 @@
-FactoryBot.define do
-
-  factory :chapter do
-    number { Faker::Number.between(1, 40) }
-    book { Organization.current.book rescue nil }
-
-    transient do
-      lessons { [] }
-      name { Faker::Lorem.sentence(3) }
-    end
-
-    after(:build) do |chapter, evaluator|
-      chapter.topic = build(:topic, name: evaluator.name, lessons: evaluator.lessons) unless evaluator.topic
-    end
-  end
-end

data/spec/factories/complement_factory.rb

@@ -1,6 +0,0 @@
-FactoryBot.define do
-
-  factory :complement, traits: [:guide_container] do
-    book { Organization.current.book rescue nil }
-  end
-end

data/spec/factories/course_factory.rb

@@ -1,9 +0,0 @@
-FactoryBot.define do
-  factory :course do
-    period { '2016' }
-    shifts { %w(morning) }
-    days { %w(monday wednesday) }
-    description { 'test' }
-    organization_id { 1 }
-  end
-end

data/spec/factories/discussion_factory.rb

@@ -1,8 +0,0 @@
-FactoryBot.define do
-  factory :discussion do
-    title { 'A discussion' }
-    description { 'A discussion description' }
-    initiator { create(:user) }
-    item { create(:exercise) }
-  end
-end

data/spec/factories/exam_factory.rb

@@ -1,9 +0,0 @@
-FactoryBot.define do
-
-  factory :exam, traits: [:guide_container] do
-    duration { Faker::Number.between(10, 60).minutes }
-    organization { Organization.current }
-    start_time { 5.minutes.ago }
-    end_time { 10.minutes.since }
-  end
-end

data/spec/factories/exercise_factory.rb

@@ -1,73 +0,0 @@
-FactoryBot.define do
-
-  factory :language do
-    sequence(:name) { |n| "lang#{n}" }
-
-    runner_url { Faker::Internet.url }
-    queriable { true }
-  end
-
-  factory :haskell, parent: :language do
-    name { 'haskell' }
-  end
-
-  factory :bash, parent: :language do
-    name { 'bash' }
-    triable { true }
-    stateful_console { true }
-  end
-
-  factory :text_language, parent: :language do
-    name { 'text' }
-  end
-
-  factory :gobstones, parent: :language do
-    name { 'gobstones' }
-    extension { 'gbs' }
-    queriable { false }
-  end
-
-  factory :exercise_base do
-    language { guide ? guide.language : create(:language) }
-    sequence(:bibliotheca_id) { |n| n }
-    sequence(:number) { |n| n }
-
-    locale { :en }
-    guide
-  end
-
-  factory :challenge, parent: :exercise_base do
-    layout { 'input_right' }
-  end
-
-  factory :reading, class: Reading, parent: :exercise_base do
-    name { 'A reading' }
-    description { 'Simple reading' }
-  end
-
-  factory :problem, class: Problem, parent: :challenge do
-    name { 'A problem' }
-    description { 'Simple problem' }
-    test { 'dont care' }
-  end
-
-  factory :interactive, class: Interactive, parent: :challenge do
-    name { 'An interactive problem' }
-    description { 'Simple interactive problem' }
-    goal { :query_passes }
-    language { create(:bash) }
-  end
-
-  factory :playground, class: Playground, parent: :challenge do
-    name { 'A Playground' }
-    description { 'Simple playground' }
-  end
-
-  factory :exercise, parent: :problem
-
-  factory :x_equal_5_exercise, parent: :exercise do
-    test { 'describe "x" $ do
-             it "should be equal 5" $ do
-                x `shouldBe` 5' }
-  end
-end

data/spec/factories/guide_factory.rb

@@ -1,30 +0,0 @@
-FactoryBot.define do
-
-  factory :guide do
-    sequence(:name) { |n| "guide#{n}" }
-    locale { 'en' }
-    description { 'A Guide' }
-    slug { "flbulgarelli/mumuki-sample-guide-#{SecureRandom.uuid}" }
-    language
-  end
-
-  trait :guide_container do
-    transient do
-      exercises { [] }
-      name { Faker::Lorem.sentence(3) }
-      description { Faker::Lorem.sentence(10) }
-      language { create(:language) }
-      slug { "mumuki/mumuki-test-lesson-#{SecureRandom.uuid}" }
-    end
-
-    after(:build) do |lesson, evaluator|
-      lesson.guide = build(:guide,
-                           name: evaluator.name,
-                           slug: evaluator.slug,
-                           exercises: evaluator.exercises,
-                           description: evaluator.description,
-                           language: evaluator.language) unless evaluator.guide
-    end
-  end
-
-end

data/spec/factories/invitation_factory.rb

@@ -1,7 +0,0 @@
-FactoryBot.define do
-  factory :invitation do
-    code { Faker::Lorem.sentence(6) }
-    course { "foo/bar" }
-    expiration_date { 5.minutes.since }
-  end
-end

data/spec/factories/lesson_factory.rb

@@ -1,7 +0,0 @@
-FactoryBot.define do
-
-  factory :lesson, traits: [:guide_container] do
-    sequence(:number)
-    topic
-  end
-end

data/spec/factories/login_settings_factory.rb

@@ -1,5 +0,0 @@
-FactoryBot.define do
-  factory :all_login_settings, class: Mumukit::Login::Settings do
-    login_methods { Mumukit::Login::Settings.login_methods }
-  end
-end

data/spec/factories/message_factory.rb

@@ -1,11 +0,0 @@
-FactoryBot.define do
-
-  factory :message do
-    exercise_id { Faker::Internet.number(2) }
-    assignment
-    submission_id { assignment.id }
-    sender { Faker::Internet.email }
-    type { 'success' }
-    content { Faker::Lorem.sentence(3) }
-  end
-end

data/spec/factories/organization_factory.rb

@@ -1,26 +0,0 @@
-FactoryBot.define do
-
-  factory :organization do
-    contact_email { Faker::Internet.email }
-    description { 'a great org' }
-    locale { 'en' }
-    settings {}
-    book
-  end
-
-  factory :base, parent: :organization do
-    public { true }
-    name { 'base' }
-    login_methods { Mumukit::Login::Settings.login_methods }
-  end
-
-  factory :public_organization, parent: :organization do
-    public { true }
-    name { 'the-public-org' }
-    login_methods { Mumukit::Login::Settings.login_methods }
-  end
-
-  factory :private_organization, parent: :organization do
-    name { 'the-private-org' }
-  end
-end

data/spec/factories/topic_factory.rb

@@ -1,9 +0,0 @@
-FactoryBot.define do
-
-  factory :topic do
-    name { Faker::Lorem::sentence(3) }
-    description { Faker::Lorem.paragraph(2) }
-    slug { "mumuki/mumuki-sample-topic-#{SecureRandom.uuid}" }
-    locale { :en }
-  end
-end

data/spec/factories/user_factory.rb

@@ -1,8 +0,0 @@
-FactoryBot.define do
-  factory :user do
-    email { Faker::Internet.email }
-    uid { email }
-    first_name { Faker::Name.first_name }
-    last_name { Faker::Name.last_name }
-  end
-end

data/spec/models/api_client_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-
-describe ApiClient, type: :model do
-  let(:api_client) {create :api_client}
-  it {expect { Mumukit::Auth::Token.decode(api_client.token).verify_client!}.to_not raise_error }
-end

data/spec/models/assignment_spec.rb

@@ -1,191 +0,0 @@
-require 'spec_helper'
-
-describe Assignment, organization_workspace: :test do
-
-  describe 'messages' do
-    let(:student) { create(:user) }
-    let(:problem) { create(:problem, manual_evaluation: true) }
-    let(:assignment) { problem.assignment_for(student) }
-    let(:message) { assignment.messages.first }
-
-    before { problem.submit_solution! student, content: '...' }
-
-    describe '.send_question!' do
-      before { problem.submit_question! student, content: 'How can i solve this?' }
-
-      it { expect(assignment.new_record?).to be false }
-      it { expect(assignment.has_messages?).to be true }
-      it { expect(message.sender).to eq student.uid }
-      it { expect(message.content).to eq 'How can i solve this?' }
-      it { expect(message.read).to be true }
-      it { expect(message.assignment).to eq assignment }
-      it { expect(message.submission_id).to eq assignment.submission_id }
-      it { expect(message.date).to_not be nil }
-    end
-
-    describe '.receive_answer!' do
-      before { problem.submit_question! student, content: 'How can i solve this?' }
-      before { assignment.receive_answer! sender: 'bot@mumuki.org', content: 'Check this link' }
-
-      it { expect(assignment.has_messages?).to be true }
-      it { expect(assignment.messages.count).to eq 2 }
-      it { expect(message.sender).to eq 'bot@mumuki.org' }
-      it { expect(message.content).to eq 'Check this link' }
-      it { expect(message.read).to be false }
-      it { expect(message.assignment).to eq assignment }
-      it { expect(message.submission_id).to eq assignment.submission_id }
-    end
-  end
-
-  describe 'manual evaluation' do
-    let(:user) { create(:user) }
-    let(:exercise) { create(:exercise, manual_evaluation: true, test: nil, expectations: []) }
-    let(:assignment) { exercise.submit_solution!(user, content: '') }
-
-    it { expect(assignment.status).to eq :manual_evaluation_pending }
-  end
-
-  describe '#results_visible?' do
-    let(:gobstones) { create(:language, visible_success_output: true) }
-    let(:gobstones_exercise) { create(:exercise, language: gobstones) }
-
-    let(:failed_submission) { create(:assignment, status: :failed) }
-    let(:passed_submission) { create(:assignment, status: :passed, expectation_results: []) }
-    let(:passed_submission_with_visible_output_language) { create(:assignment, status: :passed, exercise: gobstones_exercise) }
-    let(:manual_evaluation_pending_submission) { create(:assignment, status: :manual_evaluation_pending) }
-
-    it { expect(passed_submission.results_visible?).to be false }
-    it { expect(failed_submission.should_retry?).to be true }
-    it { expect(failed_submission.results_visible?).to be true }
-    it { expect(passed_submission_with_visible_output_language.results_visible?).to be true }
-    it { expect(manual_evaluation_pending_submission.results_visible?).to be false }
-  end
-  describe '#expectation_results_visible?' do
-    let(:haskell) { create(:language, visible_success_output: true) }
-    let(:exercise) { create(:exercise) }
-    context 'should show expectation with failed submissions' do
-      let(:failed_submission) { create(:assignment, status: :failed, expectation_results: [{binding: "foo", inspection: "HasBinding", result: :failed}]) }
-      it { expect(failed_submission.expectation_results_visible?).to be true }
-      it { expect(failed_submission.failed_expectation_results.size).to eq 1 }
-    end
-    context 'should show expectation with errored submissions' do
-      let(:errored_submission) { create(:assignment, status: :errored, expectation_results: [{binding: "foo", inspection: "HasBinding", result: :failed}]) }
-      it { expect(errored_submission.expectation_results_visible?).to be true }
-    end
-  end
-  describe '#showable_results_visible?' do
-    let(:failed_submission) { create(:assignment, exercise: problem, status: :failed, expectation_results: [{binding: "foo", inspection: "HasBinding", result: :failed},
-                                                                                                            {binding: "bar", inspection: "HasBinding", result: :failed}]) }
-
-    context 'should show all failed expectation results for regular problems' do
-      let(:problem) { create(:problem) }
-      it { expect(failed_submission.visible_expectation_results.size).to eq 2 }
-    end
-
-    context 'should show only the first failed expectation result for kids problems' do
-      let(:problem) { create(:problem, layout: 'input_kids') }
-      it { expect(failed_submission.visible_expectation_results.size).to eq 1 }
-    end
-  end
-  describe '#run_update!' do
-    let(:assignment) { create(:assignment) }
-    context 'when run passes unstructured' do
-      before { assignment.run_update! { {result: 'ok', status: :passed} } }
-      it { expect(assignment.status).to eq(:passed) }
-      it { expect(assignment.result).to eq('ok') }
-    end
-
-    context 'when run fails unstructured' do
-      before { assignment.run_update! { {result: 'ups', status: :failed} } }
-      it { expect(assignment.status).to eq(:failed) }
-      it { expect(assignment.result).to eq('ups') }
-    end
-
-    context 'when run aborts unstructured' do
-      before { assignment.run_update! { {result: 'took more thn 4 seconds', status: :aborted} } }
-      it { expect(assignment.status).to eq(:aborted) }
-      it { expect(assignment.result).to eq('took more thn 4 seconds') }
-    end
-
-    context 'when run passes with warnings unstructured' do
-      let(:runner_response) do
-        {status: :passed_with_warnings,
-         test_results: [{title: 'true is true', status: :passed, result: ''},
-                        {title: 'false is false', status: :passed, result: ''}],
-         expectation_results: [{binding: 'bar', inspection: 'HasBinding', result: :passed},
-                               {binding: 'foo', inspection: 'HasBinding', result: :failed}],
-         feedback: 'foo'}
-      end
-      before { assignment.run_update! { runner_response } }
-
-      it { expect(assignment.status).to eq(:passed_with_warnings) }
-      it { expect(assignment.result).to be_blank }
-      it { expect(assignment.test_results).to eq(runner_response[:test_results]) }
-      it { expect(assignment.expectation_results).to eq(runner_response[:expectation_results]) }
-      it { expect(assignment.feedback).to eq('foo') }
-    end
-    context 'when run raises exception' do
-      before do
-        begin
-          assignment.run_update! { raise 'ouch' }
-        rescue
-        end
-      end
-      it { expect(assignment.status).to eq(:errored) }
-      it { expect(assignment.result).to eq('ouch') }
-    end
-  end
-
-  describe '#update_submissions_count!' do
-    let(:exercise) { create(:exercise) }
-    let(:user) { create(:user) }
-
-    before do
-      exercise.submit_solution!(user)
-      exercise.submit_solution!(user)
-      exercise.submit_solution!(user)
-    end
-
-    it { expect(exercise.reload.submissions_count).to eq(3) }
-  end
-
-  describe '#submission_id' do
-    let(:exercise) { create(:exercise) }
-    let(:user) { create(:user) }
-
-    before { exercise.submit_solution!(user, content: 'foo') }
-
-    it do
-      submission_id = exercise.assignment_for(user).submission_id
-      expect(submission_id).to be_present
-
-      exercise.submit_solution!(user, content: 'bar')
-
-      new_submission_id = exercise.assignment_for(user).submission_id
-      expect(new_submission_id).to be_present
-      expect(new_submission_id).to_not eq submission_id
-    end
-  end
-
-  describe '#evaluate_manually!' do
-
-    let(:user) { create(:user) }
-    let(:exercise) { create(:exercise, manual_evaluation: true, test: nil, expectations: []) }
-    let(:assignment) { exercise.submit_solution!(user, content: '') }
-    let(:evaluated_assignment) { Assignment.find assignment.id }
-
-    before { Assignment.evaluate_manually! submission_id: assignment.submission_id, manual_evaluation: '**Good**', status: 'passed_with_warnings' }
-
-    it { expect(evaluated_assignment.status).to eq :passed_with_warnings }
-    it { expect(evaluated_assignment.manual_evaluation_comment).to eq '**Good**' }
-  end
-
-  describe '#extra' do
-    let(:user) { create(:user, email: 'some_email', first_name: 'some_first_name', last_name: 'some_last_name') }
-    let(:exercise) { create(:exercise, extra: "/*...user_email...*/\n/*...user_first_name...*/\n/*...user_last_name...*/") }
-    let(:assignment) { exercise.submit_solution!(user, content: '') }
-
-    it { expect(assignment.extra).to eq "some_email\nsome_first_name\nsome_last_name\n" }
-  end
-
-end