sample_spec.rb

  context 'Test all instance methods' do

    let(:test_user) { create(:th_user) }
    let(:superbadge) do
      create(
        :th_superbadge,
        api_name: 'test_super_badge',
        first_ascent_points: 1000,
        completion_points: 1000
      )
    end
    let(:prerequisite1)              { create(:th_module, api_name: 'prerequisite_1') }
    let(:prerequisite1_unit1)        { create(:unit, api_name: 'test_id_1') }
    let(:super_badge_section1)       { create(:section, api_name: 'test_id_2') }
    let(:super_badge_section2)       { create(:section, api_name: 'test_id_3') }
    let(:super_badge_section3)       { create(:section, api_name: 'test_id_4') }
    let(:user_superbadge)            { create(:th_user_superbadge,
                                                 module_couch_id: superbadge.api_name,
                                                 unit_couch_ids_list: 'test_id_2,test_id_3,test_id_4',
                                                 user: test_user,
                                                 state: Th::STATE_IN_PROGRESS
                                                 )
                                         }
    let(:super_badge_prerequisite)      { create(:th_user_module,
                                                 type: Th::UserModule,
                                                 module_couch_id: prerequisite1.api_name,
                                                 unit_couch_ids_list: prerequisite1_unit1.api_name,
                                                 user: test_user,
                                                 state: Th::STATE_IN_PROGRESS
                                                 )

                                        }

    let(:lesson_section1) { create(:user_section,
                                   :in_progress,
                                   user: test_user,
                                   unit_couch_id: super_badge_section1.api_name,
                                   user_module: user_superbadge
                                   )
                           }
    let(:lesson_section2) { create(:user_section,
                                   :in_progress,
                                   user: test_user,
                                   unit_couch_id: super_badge_section2.api_name,
                                   user_module: user_superbadge
                                   )
                           }
    let(:lesson_section3) { create(:user_section,
                                   :in_progress,
                                   user: test_user,
                                   unit_couch_id: super_badge_section3.api_name,
                                   user_module: user_superbadge
                                   )
                           }
    let!(:point)           { create(:user_point,
                                    point_source: lesson_section1,
                                    user: test_user,
                                    organization_id: lesson_section1.organization_id,
                                    tag_couch_id: 'test_tag',
                                    points: 456
                                    )
                           }
    let!(:tag_content)     { create(:tag, couch_id: 'some_tag', title: 'A Tag') }

    let(:tags)             { create_list(:tag, 3) }

    let(:challenge) do
      OpenStruct.new (
        {
          tag_points: [
            {
              'tag_id' => 'test_challenge_1',
              'title' => 'test title 1',
              'points' => 210
            },
            {
              'tag_id' => 'test_challenge_2',
              'title' => 'test title 2',
              'points' => 20
            }
          ],
          code_evaluation_json: {
            questions: [
              {
                questions: 'Hello',
                options: %w(a b c d),
                answers: ['a']
              }
            ]
          }
        }
      )
    end

    before do
      allow(prerequisite1_unit1).to receive(:challenge).and_return(challenge)
      allow(super_badge_section1).to   receive(:challenge).and_return(challenge)
      allow(super_badge_section2).to   receive(:challenge).and_return(challenge)
      allow(super_badge_section3).to   receive(:challenge).and_return(challenge)

      allow(super_badge_section1).to receive(:total_tag_points).and_return(230)

      prerequisite1.base_units       << prerequisite1_unit1

      superbadge.prerequisites << prerequisite1
      superbadge.tags << tag_content
      superbadge.base_units << [
        super_badge_section1,
        super_badge_section2,
        super_badge_section3
      ]

      user_superbadge.user_units << lesson_section1
      user_superbadge.user_units << lesson_section2
      user_superbadge.user_units << lesson_section3
    end

    it 'should return true for an in_progress superbadge' do
      user_superbadge.mark_complete!
      expect(superbadge.in_progress?(test_user.id)).to be_falsy
    end

    it 'should return true for a completed superbadge' do
      user_superbadge.mark_complete!
      expect(superbadge.completed?(test_user.id)).to be_truthy
      user_superbadge.mark_in_progress!
    end

    it 'should return a list of completed prerequisites' do
      super_badge_prerequisite.mark_complete!
      expect(superbadge.send(:prerequisite_courses, test_user.id).count).to eq(1)
      expect(superbadge.send(:prerequisite_courses, test_user.id)).to include(super_badge_prerequisite)
      super_badge_prerequisite.mark_in_progress!
    end

    it 'should have formatted user prerequisites' do
      user_prerequisites = superbadge.user_prerequisites(test_user.id)
      expect(user_prerequisites).to be_kind_of Array
      expect(user_prerequisites.first).to be_kind_of OpenStruct
    end

    it 'should have formatted user units' do
      user_units = superbadge.user_units(test_user.id)
      expect(user_units).to be_kind_of Array
      expect(user_units.first).to be_kind_of OpenStruct
      expect(user_units.first.earned_points).to eq(456)
    end

    it 'should update last attempted at for the course super badge' do
      user_superbadge.update_last_attempted
      expect(user_superbadge.last_attempted_at).to be_within(2.second).of Time.now
    end

    it 'should return if superbadge was done first ascent' do
      expect(user_superbadge.first_ascent?).to be_falsy
      lesson_section1.mark_complete
      lesson_section2.mark_complete
      lesson_section3.mark_complete
      user_superbadge.find_and_set_state(test_user.id)
      expect(user_superbadge.first_ascent?).to be_truthy
    end

    it 'should track and update course super badge statuses' do
      expect(user_superbadge.completed?).to be_falsy
      lesson_section1.mark_complete
      lesson_section2.mark_complete
      lesson_section3.mark_complete
      user_superbadge.find_and_set_state(test_user.id)
      expect(user_superbadge.completed?).to be_truthy
    end

    it 'should return 0 challenge points for a incompleted superbadge lesson' do
      expect(superbadge.challenge_points(test_user.id)).to eq(0)
    end

    it 'should return 0 challenge points for a completed superbadge lesson' do
      lesson_section1.mark_complete
      expect(superbadge.challenge_points(test_user.id)).to eq(point.points)
    end

    it 'should create a point record for a completed superbadge' do
      expect(user_superbadge.completed?).to be_falsy

      lesson_section1.mark_complete
      lesson_section2.mark_complete
      lesson_section3.mark_complete

      user_superbadge.find_and_set_state(test_user.id)

      expect(Th::UserPoint.all.map(&:points).sum).to eq(
        superbadge.first_ascent_points +
        superbadge.completion_points +
        point.points
      )
    end

    describe '#completed_modules' do
      it 'should return the true for each completed_module for the user' do
        super_badge_prerequisite.mark_complete!
        completed_modules = superbadge.completed_modules(test_user.id)
        expect(completed_modules).to be_kind_of Array
        expect(completed_modules.first).to be_kind_of Th::UserModule
      end
    end

    describe '#update_course_super_badge' do
      let(:user_id) { test_user.id }

      subject { superbadge.update_course_super_badge(user_id) }

      context 'User-activity record does not exist' do
        before do
          Th::UserSuperbadge.where(user: test_user).destroy_all
          expect(superbadge.course_super_badge(user_id)).to be_blank
        end

        it 'creates an In-Progress user-activity record' do
          expect { subject }.to change { Th::UserSuperbadge.in_progress.for_user(test_user).count }.by 1
        end
      end

      context 'User-activity record exists' do
        before { expect(superbadge.course_super_badge(user_id)).to be_present }

        it 'does not create a user-activity record if there exists one already' do
          expect { subject }.not_to change {
            Th::UserSuperbadge.in_progress.for_user(test_user).count
          }
        end
      end

      context 'all sections completed' do
        let(:user_sections) { [lesson_section1, lesson_section2, lesson_section3] }

        before { user_sections.each(&:mark_complete) }

        it 'marks Superbadge as completed' do
          expect { subject }.to change { Th::UserSuperbadge.completed.for_user(test_user).count }.by 1
        end
      end
    end
  end