mumuki-laboratory 7.3.1 → 7.5.1

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

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Book do
+  let!(:haskell) { create(:haskell) }
+  let!(:gobstones) { create(:gobstones) }
+
+  let!(:guide_1) { create(:guide, name: 'a lesson') }
+  let!(:guide_2) { create(:guide, name: 'other lesson') }
+
+  let!(:topic_1) { create(:topic, name: 'a topic') }
+  let!(:topic_2) { create(:topic, name: 'other topic') }
+
+
+  let(:book_resource_h) do
+    {name: 'sample book',
+      description: 'a sample book description',
+      slug: 'mumuki/a-book',
+      locale: 'en',
+      chapters: [topic_1.slug, topic_2.slug],
+      complements: complement_slugs,
+    }
+  end
+
+  let(:complement_slugs) { [] }
+
+  describe '#sync_key' do
+    let(:book) { create(:book, slug: 'mumuki/a-book') }
+
+    it { expect(book.sync_key).to eq Mumukit::Sync.key(Book, 'mumuki/a-book')}
+  end
+
+  describe '.import_from_resource_h!' do
+    let(:book) { Book.import_from_resource_h! book_resource_h }
+
+    it { expect(book.sync_key).to eq Mumukit::Sync.key(Book, 'mumuki/a-book') }
+  end
+
+  describe '#import_from_resource_h!', organization_workspace: :test do
+    let(:book) { Organization.current.book }
+
+    context 'when complements are present' do
+      let(:complement_slugs) { [guide_2.slug, guide_1.slug] }
+
+      before { book.import_from_resource_h!(book_resource_h) }
+
+      it 'imports data succesfully' do
+        expect(book.name).to eq 'sample book'
+        expect(book.description).to eq 'a sample book description'
+        expect(book.locale).to eq 'en'
+        expect(book.chapters.count).to eq 2
+        expect(book.complements.count).to eq 2
+      end
+
+      it 'reindexes usages properly' do
+        expect(topic_2.reload.usage_in_organization).to be_a Chapter
+        expect(guide_2.reload.usage_in_organization).to be_a Complement
+      end
+
+      it { expect(book.sync_key).to eq Mumukit::Sync.key(Book, 'mumuki/a-book') }
+    end
+
+    context 'when complements are not present' do
+      let(:complement_slugs) { ['foo/bar', guide_1.slug] }
+
+      before { book.import_from_resource_h!(book_resource_h) }
+
+      it { expect(book.complements.count).to eq 1 }
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe Book, organization_workspace: :test do
+  let(:book) { Organization.current.book }
+
+  describe 'book normalization' do
+    let(:book) { create(:book, slug: 'fLbUlGaReLlI/MuMUkI-saMPle-gUIde') }
+
+    it { expect(book.slug).to eq('flbulgarelli/mumuki-sample-guide') }
+  end
+
+  describe 'fork_to!' do
+    let(:original_book) do
+      create(:book,
+        slug: 'original/book',
+        chapters: [
+          create(:chapter,
+            slug: 'original/topic1',
+            lessons: [
+              create(:lesson, slug: 'original/guide1'),
+              create(:lesson, slug: 'original/guide2')]),
+          create(:chapter,
+            slug: 'original/topic2',
+            lessons: [
+              create(:lesson, slug: 'original/guide3'),
+              create(:lesson, slug: 'original/guide4')])])
+    end
+
+    let(:new_guides) { new_book.reload.chapters.map(&:topic).flat_map(&:lessons).map(&:guide) }
+
+    shared_examples_for 'a successful fork operation' do
+      let!(:new_book) { original_book.fork_to! 'new', Mumukit::Sync::Syncer.new(Mumukit::Sync::Store::NullStore.new) }
+
+      it "forks properly" do
+        expect(new_book.slug).to eq 'new/book'
+        expect(new_book.chapters.map(&:slug)).to eq %w(new/topic1 new/topic2)
+        expect(new_guides.map(&:slug)).to eq %w(new/guide1 new/guide2 new/guide3 new/guide4)
+
+        expect(Book.find_by_slug 'new/book').to be_present
+        expect(Topic.find_by_slug 'new/topic1').to be_present
+        expect(Topic.find_by_slug 'new/topic2').to be_present
+        expect(Guide.find_by_slug 'new/guide1').to be_present
+        expect(Guide.find_by_slug 'new/guide2').to be_present
+        expect(Guide.find_by_slug 'new/guide3').to be_present
+        expect(Guide.find_by_slug 'new/guide4').to be_present
+      end
+    end
+
+    context 'when no content has been previously forked' do
+      it_behaves_like 'a successful fork operation'
+    end
+
+    context 'when some content has been previously forked' do
+      before { create :guide, slug: 'new/guide2' }
+      before { create :guide, slug: 'new/guide4' }
+
+      it_behaves_like 'a successful fork operation'
+    end
+  end
+
+  describe '#next_lesson_for' do
+    let!(:chapter) { create(:chapter, lessons: [create(:lesson)]) }
+    let(:fresh_user) { create(:user) }
+
+    before { reindex_current_organization! }
+
+    it { expect(book.next_lesson_for(nil)).to eq book.first_lesson }
+    it { expect(book.next_lesson_for(fresh_user)).to eq book.first_lesson }
+  end
+
+  describe '#rebuild!' do
+    let(:chapter_1) { build(:chapter, number: 10) }
+    let(:chapter_2) { build(:chapter, number: 8) }
+
+    let(:lesson_1) { create(:lesson) }
+    let(:lesson_2) { create(:lesson) }
+    let(:lesson_3) { create(:lesson) }
+
+    let(:guide_1) { lesson_1.guide }
+    let(:guide_2) { lesson_2.guide }
+    let(:guide_3) { lesson_3.guide }
+
+    context 'when chapter is rebuilt after book rebuilt' do
+      before do
+        book.description = '#foo'
+        book.rebuild_chapters!([chapter_1, chapter_2])
+
+        chapter_1.rebuild_lessons!([lesson_1, lesson_2])
+        chapter_2.rebuild_lessons!([lesson_3])
+      end
+
+
+      it "rebuilds successfully" do
+        expect(book.description).to eq '#foo'
+        expect(book.description_html).to eq "<h1>foo</h1>\n"
+
+        expect(Chapter.count).to eq 2
+        expect(book.chapters).to eq [chapter_1, chapter_2]
+        expect(chapter_1.guides).to eq [guide_1, guide_2]
+        expect(chapter_2.guides).to eq [guide_3]
+        expect(chapter_1.number).to eq 1
+        expect(chapter_2.number).to eq 2
+      end
+    end
+
+    context 'when some chapters are orphan' do
+      let(:orphan_chapter) { build(:chapter, book: nil) }
+      before do
+        book.description = '#foo'
+        book.rebuild_chapters!([chapter_1, orphan_chapter, chapter_2])
+
+        chapter_1.rebuild_lessons!([lesson_1, lesson_2])
+        chapter_2.rebuild_lessons!([lesson_3])
+      end
+
+      it "rebuilds successfully" do
+        expect(book.description).to eq '#foo'
+        expect(book.description_html).to eq "<h1>foo</h1>\n"
+
+        expect(Chapter.count).to eq 3
+        expect(book.chapters).to eq [chapter_1, orphan_chapter, chapter_2]
+        expect(chapter_1.guides).to eq [guide_1, guide_2]
+        expect(chapter_2.guides).to eq [guide_3]
+        expect(chapter_1.number).to eq 1
+        expect(orphan_chapter.number).to eq 2
+        expect(chapter_2.number).to eq 3
+      end
+    end
+
+
+    context 'when chapter is created before book rebuilt' do
+      before do
+        chapter_1.save!
+        chapter_2.save!
+
+        book.description = '#foo'
+        book.rebuild_chapters!([chapter_1, chapter_2])
+
+        chapter_1.rebuild_lessons!([lesson_1, lesson_2])
+        chapter_2.rebuild_lessons!([lesson_3])
+      end
+
+      it "rebuilds successfully" do
+        expect(book.description).to eq '#foo'
+        expect(book.description_html).to eq "<h1>foo</h1>\n"
+
+        expect(Chapter.count).to eq 2
+        expect(book.chapters).to eq [chapter_1, chapter_2]
+        expect(chapter_1.guides).to eq [guide_1, guide_2]
+        expect(chapter_2.guides).to eq [guide_3]
+        expect(chapter_1.number).to eq 1
+        expect(chapter_2.number).to eq 2
+      end
+    end
+
+    context 'when chapter is rebuilt before book rebuilt' do
+      before do
+        chapter_1.rebuild_lessons!([lesson_1, lesson_2])
+        chapter_2.rebuild_lessons!([lesson_3])
+
+        book.description = '#foo'
+        book.rebuild_chapters!([chapter_1, chapter_2])
+      end
+
+      it "rebuilds successfully" do
+        expect(book.description).to eq '#foo'
+        expect(book.description_html).to eq "<h1>foo</h1>\n"
+
+        expect(Chapter.count).to eq 2
+        expect(book.chapters).to eq [chapter_1, chapter_2]
+        expect(chapter_1.number).to eq 1
+        expect(chapter_2.number).to eq 2
+        expect(chapter_1.guides).to eq [guide_1, guide_2]
+        expect(chapter_2.guides).to eq [guide_3]
+      end
+    end
+
+    context 'when rebuilt content changes' do
+      let(:guide_1) { create :indexed_guide }
+      let(:guide_2) { create :indexed_guide }
+
+      let(:chapter_1) { guide_1.chapter }
+      let(:chapter_2) { guide_2.chapter }
+
+      before { book.rebuild_chapters!([chapter_1, chapter_2]) }
+
+      let!(:chapter_1_usage) { Usage.find_by parent_item: chapter_1 }
+      let!(:chapter_2_usage) { Usage.find_by parent_item: chapter_2 }
+      let!(:guide_1_usage) { Usage.find_by item: guide_1 }
+      let!(:guide_2_usage) { Usage.find_by item: guide_2 }
+
+      before { book.rebuild_chapters!([chapter_2]) }
+
+      it { expect { chapter_1.reload }.to raise_error ActiveRecord::RecordNotFound }
+      it { expect { chapter_2.reload }.to_not raise_error }
+      it { expect { chapter_1_usage.reload }.to raise_error ActiveRecord::RecordNotFound }
+      it { expect { chapter_2_usage.reload }.to_not raise_error }
+      it { expect { guide_1_usage.reload }.to raise_error ActiveRecord::RecordNotFound }
+      it { expect { guide_2_usage.reload }.to_not raise_error }
+      it { expect(Chapter.count).to eq 1 }
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe 'CourseChanged', organization_workspace: :test do
+  let(:course_json) do
+    {slug: 'test/bar',
+     shifts: %w(morning),
+     code: 'k2003',
+     days: %w(monday wednesday),
+     period: '2016',
+     description: 'test course'}
+  end
+
+  let!(:course) { Course.import_from_resource_h! course_json }
+
+  it { expect(course.organization.courses).to include course }
+  it { expect(course.organization.name).to eq 'test' }
+
+  it { expect(course.slug).to eq 'test/bar' }
+  it { expect(course.code).to eq 'k2003' }
+  it { expect(course.days).to eq %w(monday wednesday) }
+  it { expect(course.period).to eq '2016' }
+
+  describe '#invite!' do
+    context 'when an invitation has not been created yet' do
+      it { expect(course.current_invitation).to be nil }
+      it { expect(course.closed?).to be true }
+    end
+
+    context 'when an invitation has been created' do
+      let(:expiration_date) { 2.days.since }
+      let!(:invitation) { course.invite! expiration_date  }
+
+      it { expect(invitation.expiration_date).to eq expiration_date }
+      it { expect(invitation.code).to_not be nil }
+      it { expect(course.invitations).to eq [invitation] }
+      it { expect(course.current_invitation).to eq invitation }
+      it { expect(course.closed?).to be false }
+    end
+
+    context 'when an invitation has been created and then re-created before expiration' do
+      let(:old_expiration) { 1.day.since.beginning_of_day }
+
+      before { course.invite! old_expiration }
+      let!(:invitation) { course.invite! 2.days.since  }
+
+      # This behaviour is debatable, but it is the current expected behaviour
+      it { expect(invitation.expiration_date).to eq old_expiration }
+      it { expect(invitation.code).to_not be nil }
+      it { expect(course.invitations.size).to eq 1 }
+      it { expect(course.current_invitation).to eq invitation }
+      it { expect(course.closed?).to be false }
+    end
+
+    context 'when an invitation has been created and then re-created after expiration' do
+      before { course.invite! 1.day.ago }
+
+      let(:new_expiration) { 2.days.since }
+      let!(:invitation) { course.invite! new_expiration  }
+
+      it { expect(invitation.expiration_date).to eq new_expiration }
+      it { expect(invitation.code).to_not be nil }
+      it { expect(course.invitations.size).to eq 2 }
+      it { expect(course.current_invitation).to eq invitation }
+      it { expect(course.closed?).to be false }
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+describe Discussion, organization_workspace: :test do
+
+  context 'when created' do
+    let(:initiator) { create(:user) }
+    let(:student) { create(:user) }
+    let(:problem) { create(:problem) }
+    let(:discussion) { problem.discuss! initiator, title: 'Need help' }
+    let(:moderator) { create(:user, permissions: {moderator: 'test/*'}) }
+
+    it { expect(discussion.new_record?).to be false }
+    it { expect(discussion.has_responses?).to be false }
+    it { expect(discussion.messages).to eq [] }
+    it { expect(discussion.initiator).to eq initiator }
+    it { expect(discussion.title).to eq 'Need help' }
+    it { expect(discussion.item).to eq problem }
+    it { expect(initiator.subscribed_to? discussion).to be true }
+    it { expect(discussion.status).to eq :opened }
+    it { expect(discussion.reachable_statuses_for initiator).to eq [:closed] }
+    it { expect(discussion.reachable_statuses_for moderator).to eq [:closed] }
+    it { expect(discussion.reachable_statuses_for student).to eq [] }
+    it { expect(discussion.commentable_by? student).to be true }
+    it { expect(discussion.commentable_by? moderator).to be true }
+
+    describe 'initiator sends a message' do
+      before { discussion.submit_message!({content: 'I forgot to say this'}, initiator)  }
+
+      it { expect(discussion.has_responses?).to be false }
+      it { expect(discussion.messages.first.content).to eq 'I forgot to say this' }
+      it { expect(initiator.unread_discussions).to eq [] }
+      it { expect(discussion.reachable_statuses_for initiator).to eq [:closed] }
+      it { expect(discussion.reachable_statuses_for moderator).to eq [:closed] }
+      it { expect(discussion.reachable_statuses_for student).to eq [] }
+
+      describe 'and closes the discussion' do
+        before { discussion.update_status!(:closed, initiator) }
+
+        it { expect(discussion.status).to eq :closed }
+        it { expect(discussion.reachable_statuses_for initiator).to eq [] }
+        it { expect(discussion.reachable_statuses_for moderator).to eq [:opened, :solved] }
+        it { expect(discussion.reachable_statuses_for student).to eq [] }
+        it { expect(discussion.commentable_by? student).to be false }
+        it { expect(discussion.commentable_by? moderator).to be true }
+      end
+    end
+
+    describe 'receive message from helper' do
+      before { discussion.submit_message!({content: 'You should do this'}, student)  }
+
+      it { expect(discussion.has_responses?).to be true }
+      it { expect(initiator.unread_discussions).to include discussion }
+      it { expect(discussion.messages.first.content).to eq 'You should do this' }
+      it { expect(discussion.reachable_statuses_for initiator).to eq [:pending_review] }
+      it { expect(discussion.reachable_statuses_for moderator).to eq [:closed, :solved] }
+      it { expect(discussion.reachable_statuses_for student).to eq [] }
+      it { expect(student.subscribed_to? discussion).to be true }
+
+      describe 'gets updated to pending_review by initiator' do
+        before { discussion.update_status!(:pending_review, initiator) }
+
+        it { expect(discussion.status).to eq :pending_review }
+        it { expect(discussion.reachable_statuses_for initiator).to eq [] }
+        it { expect(discussion.reachable_statuses_for moderator).to eq [:opened, :closed, :solved] }
+        it { expect(discussion.reachable_statuses_for student).to eq [] }
+        it { expect(discussion.commentable_by? student).to be false }
+        it { expect(discussion.commentable_by? moderator).to be true }
+      end
+
+      describe 'initiator tries to solve it' do
+        it { expect { discussion.update_status!(:solved, initiator) }.not_to change(discussion, :status) }
+      end
+
+      describe 'gets solved by moderator' do
+        before { discussion.update_status!(:solved, moderator) }
+
+        it { expect(discussion.status).to eq :solved }
+        it { expect(discussion.reachable_statuses_for initiator).to eq [] }
+        it { expect(discussion.reachable_statuses_for moderator).to eq [:opened, :closed] }
+        it { expect(discussion.reachable_statuses_for student).to eq [] }
+        it { expect(discussion.commentable_by? student).to be false }
+        it { expect(discussion.commentable_by? moderator).to be true }
+      end
+    end
+  end
+
+  describe '#toggle_subscription!' do
+    let(:discussion) { create(:discussion, {organization: Organization.current}) }
+
+    context 'when the student is not subscribed' do
+      let(:student) { create(:user) }
+
+      before { student.toggle_subscription!(discussion) }
+
+      it { expect(student.subscribed_to? discussion).to be true }
+    end
+
+    context 'when the student is subscribed' do
+      let(:student) { create(:user, watched_discussions: [discussion]) }
+
+      before { student.toggle_subscription!(discussion) }
+
+      it { expect(student.subscribed_to? discussion).to be false }
+    end
+  end
+
+  describe '#toggle_upvote!' do
+    let(:discussion) { create(:discussion, {organization: Organization.current}) }
+
+    context 'when the student has not upvoted' do
+      let(:student) { create(:user) }
+
+      before { student.toggle_upvote!(discussion) }
+
+      it { expect(student.upvoted? discussion).to be true }
+      it { expect(discussion.reload.upvotes_count).to be 1 }
+    end
+
+    context 'when the student is subscribed' do
+      let(:student) { create(:user, upvoted_discussions: [discussion]) }
+
+      before { student.toggle_upvote!(discussion) }
+
+      it { expect(student.upvoted? discussion).to be false }
+      it { expect(discussion.reload.upvotes_count).to be 0 }
+    end
+  end
+
+  describe '#debatable_for' do
+    let(:exercise) { create(:problem) }
+
+    it { expect(described_class.debatable_for('Exercise', {exercise_id: exercise.id})).to eq exercise }
+  end
+
+  describe 'scope for user' do
+    let(:initiator) { create(:user) }
+    let(:other_user) { create(:user) }
+    let(:exercise) { create(:problem) }
+
+    let!(:public_discussions) { [:opened, :solved].map { |it| exercise.discuss!(initiator, {status: it, title: 'A disc'}) } }
+    let!(:private_discussions ) { [:pending_review, :closed].map { |it| exercise.discuss!(initiator, {status: it, title: 'A disc'}) } }
+    let!(:other_discussion) { exercise.discuss!(other_user, {status: :closed, title: 'A disc'}) }
+
+    context 'as student' do
+      let(:student) { create(:user) }
+      it { expect(exercise.discussions.for_user(student)).to match_array public_discussions }
+    end
+
+    context 'as initiator' do
+      it { expect(exercise.discussions.for_user(initiator)).to match_array public_discussions + private_discussions }
+    end
+
+    context 'as moderator' do
+      let(:moderator) { create(:user, permissions: {moderator: 'test/*'}) }
+      it { expect(exercise.discussions.for_user(moderator)).to match_array public_discussions + private_discussions + [other_discussion] }
+    end
+
+    context 'for other item' do
+      let(:other_exercise) { create(:exercise) }
+      it { expect(other_exercise.discussions.for_user(initiator)).to be_empty }
+    end
+  end
+
+  describe 'messages not being deleted' do
+    let(:user) { create(:user) }
+    let(:other_user) { create(:user) }
+    let(:problem) { create(:problem) }
+    let(:assignment) { problem.submit_solution! user }
+    let(:discussion) { problem.discuss!(user, {title: 'A discussion'})}
+
+    before { discussion.submit_message!({content: 'You should do this'}, user) }
+    before { problem.submit_solution! other_user }
+
+    it { expect(discussion.messages.count).to eq 1 }
+  end
+end