mumuki-laboratory 7.9.2 → 7.10.0

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

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

@@ -1,324 +0,0 @@
-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
-
-  describe 'enabled chapters' do
-    let(:exercise_1) { create(:exercise) }
-    let(:exercise_2) { create(:exercise) }
-    let(:exercise_3) { create(:exercise) }
-
-    let(:chapter_1) { build(:chapter, lessons: [create(:lesson, exercises: [exercise_1])]) }
-    let(:chapter_2) { build(:chapter, lessons: [create(:lesson, exercises: [exercise_2, exercise_3])]) }
-    let(:chapter_3) { build(:chapter, lessons: [create(:lesson)]) }
-
-    before { book.rebuild_chapters! [chapter_1, chapter_2, chapter_3] }
-
-    let(:organization) { Organization.current }
-    let(:workspace) { Mumuki::Domain::Workspace.new(user, organization) }
-
-    shared_examples_for 'full display' do
-      it { expect(book.enabled_chapters_in(workspace)).to eq [chapter_1, chapter_2, chapter_3] }
-      it { expect(book.chapter_visibilities_in(workspace)).to eq [[chapter_1, true], [chapter_2, true], [chapter_3, true]] }
-    end
-
-    context 'non-progressive display' do
-      context 'when annonymous user' do
-        let(:user) { nil }
-        it_behaves_like 'full display'
-      end
-
-      context 'when fresh user' do
-        let(:user) { create(:user) }
-        it_behaves_like 'full display'
-      end
-    end
-
-    context 'progressive display-1' do
-      before { organization.enable_progressive_display! }
-
-      context 'when annonymous user' do
-        let(:user) { nil }
-        it_behaves_like 'full display'
-      end
-
-      context 'when fresh user' do
-        let(:user) { create(:user) }
-        it { expect(book.enabled_chapters_in(workspace)).to eq [chapter_1] }
-      end
-
-      context 'when user with incomplete progress in first chapter' do
-        let(:user) { create(:user) }
-
-        before do
-          exercise_1.submit_solution!(user)
-        end
-
-        it { expect(book.enabled_chapters_in(workspace)).to eq [chapter_1] }
-        it { expect(book.chapter_visibilities_in(workspace)).to eq [[chapter_1, true], [chapter_2, false], [chapter_3, false]] }
-      end
-
-      context 'when user with full progress in first chapter' do
-        let(:user) { create(:user) }
-
-        before do
-          exercise_1.submit_solution!(user).passed!
-        end
-
-        it { expect(book.enabled_chapters_in(workspace)).to eq [chapter_1, chapter_2] }
-        it { expect(book.chapter_visibilities_in(workspace)).to eq [[chapter_1, true], [chapter_2, true], [chapter_3, false]] }
-      end
-
-      context 'when user with incomplete progress in second chapter' do
-        let(:user) { create(:user) }
-
-        before do
-          exercise_1.submit_solution!(user).passed!
-          exercise_2.submit_solution!(user).passed!
-        end
-
-        it { expect(book.enabled_chapters_in(workspace)).to eq [chapter_1, chapter_2] }
-        it { expect(book.chapter_visibilities_in(workspace)).to eq [[chapter_1, true], [chapter_2, true], [chapter_3, false]] }
-      end
-
-
-      context 'when user with incomplete progress in third chapter' do
-        let(:user) { create(:user) }
-
-        before do
-          exercise_1.submit_solution!(user).passed!
-          exercise_2.submit_solution!(user).passed!
-          exercise_3.submit_solution!(user).passed!
-        end
-
-        it_behaves_like 'full display'
-      end
-
-      context 'when teacher user' do
-        let(:user) { create(:user) }
-        before { user.make_teacher_of! organization }
-
-        it_behaves_like 'full display'
-      end
-    end
-
-    context 'progressive display-2' do
-      before { organization.enable_progressive_display! lookahead: 2 }
-
-      context 'when annonymous user' do
-        let(:user) { nil }
-        it_behaves_like 'full display'
-      end
-
-      context 'when fresh user' do
-        let(:user) { create(:user) }
-        it { expect(book.enabled_chapters_in(workspace)).to eq [chapter_1, chapter_2] }
-      end
-
-      context 'when teacher user' do
-        let(:user) { create(:user) }
-        before { user.make_teacher_of! organization }
-
-        it_behaves_like 'full display'
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-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.beginning_of_day }
-      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.beginning_of_day }
-      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