high_school_coursework_report_test.rb

require "test_helper"
require "csv_parser"
require "support/reports_unit_test_helper"
require "benchmark"

describe Reports::HighSchoolCourseworkReport do
  let(:described_class) { Reports::HighSchoolCourseworkReport }

  def random_word(l)
    (0...l).map { (65 + rand(26)).chr }.join
  end

  def grade_levels
    @grade_levels ||= GlobalLookups::GradeLevel.all
  end

  def secondary_school_term_types
    @term_types ||= GlobalLookups::SecondarySchoolTermType.all
  end

  def secondary_school_course_selections
    @course_selections ||= GlobalLookups::SecondarySchoolCourseSelection.all
  end

  def secondary_school_course_classifications
    @course_classifications ||= GlobalLookups::SecondarySchoolCourseClassification.all
  end

  def random_grade_level
    grade_levels.sample
  end

  def random_term_type
    secondary_school_term_types.sample
  end

  def random_course_selection
    secondary_school_course_selections.sample
  end

  def random_course_classification
    secondary_school_course_classifications.sample
  end

  def create_courses(grade_level)
    applicant = grade_level.applicant
    cas = applicant.cas
    secondary_school = grade_level.secondary_school

    course_count = (6..10).to_a.sample
    course_count.times do |_|
      term_type = random_term_type
      course_selection = random_course_selection
      secondary_school_course_classification = random_course_classification

      create(:secondary_school_course, applicant: applicant, cas: cas, secondary_school: secondary_school,
             secondary_school_grade_level: grade_level, secondary_school_term_type: term_type,
             secondary_school_course_selection: course_selection,
             secondary_school_course_classification: secondary_school_course_classification,
             title: random_word((10..20).to_a.sample),
             fall_grade: "A-", full_year_grade: "C-", q1_grade: "A", q2_grade: "B+", q3_grade: "B", q4_grade: "B-", spring_grade: "C",
             summer_grade: "A+", winter_grade: "C+")

    end
  end

  def create_grade_level(secondary_school)
    applicant = secondary_school.applicant
    cas = applicant.cas
    grade_level = random_grade_level
    secondary_school_grade_level = create(:secondary_school_grade_level, grade_level: grade_level, applicant: applicant, cas: cas,
                                          secondary_school: secondary_school, academic_year: "2006-2007")
    create_courses(secondary_school_grade_level)
  end

  def create_secondary_school(applicant, unique_schools)
    master_secondary_school = nil
    name = nil

    if rand < 0.75
      master_secondary_school = create(:master_secondary_school, name: random_word(12), code: random_word(8))
    else
      name = random_word(12)
    end

    secondary_school = create(:secondary_school, applicant: applicant, home_school: false,
                              master_secondary_school: master_secondary_school, name: name)

    (4 / unique_schools).times do
      create_grade_level(secondary_school)
    end
  end

  def create_applicant(cas)
    applicant = build(:applicant, cas: cas, first_name: random_word(8), last_name: random_word(12))
    applicant.cas_id = applicant.identifier
    applicant.save!
    unique_school_count = [1, 1, 1, 1, 2, 2, 2, 3, 3, 4].sample

    unique_school_count.times do |_|
      create_secondary_school(applicant, unique_school_count)
    end
  end

  describe "with data" do
    before do
      GlobalLookups::GradeLevel.create_all
      GlobalLookups::SecondarySchoolTermType.create_all
      GlobalLookups::SecondarySchoolCourseSelection.create_all
      GlobalLookups::SecondarySchoolCourseClassification.create_all
      cas = create(:cas)
      1000.times do
        create_applicant(cas)
      end
      cas = nil
      @grade_levels = nil
      @term_types = nil
      @course_selections = nil
      @course_classifications = nil
      GC.start
    end

    it "generates expected CSV format" do
      user_identity = build_stubbed(:organization_user_identity)
      report = build(:report)

      ar_start = ObjectSpace.each_object(ActiveRecord::Base)
      term_type_start = ObjectSpace.each_object(GlobalLookups::SecondarySchoolTermType).count

      GC.disable
      # Change logger
      old_logger = ActiveRecord::Base.logger
      ActiveRecord::Base.logger = Logger.new(STDOUT)
      time = Benchmark.realtime do
        csv = ReportsUnitTestHelper::Renderer.to_raw_csv(described_class, user_identity, report, all_applicants, all_applicants)
        parsed_csv = parse_coursework_report(csv)
        #puts parsed_csv
      end

      puts "Total Time: #{time}"
      puts "Courses: #{ObjectSpace.each_object(SecondarySchoolCourse).count}"
      puts "Term Type: #{ObjectSpace.each_object(GlobalLookups::SecondarySchoolTermType).count}"
      puts "Grade Level: #{ObjectSpace.each_object(GlobalLookups::GradeLevel).count}"
      puts "Classification: #{ObjectSpace.each_object(GlobalLookups::SecondarySchoolCourseClassification).count}"
      puts "Selection: #{ObjectSpace.each_object(GlobalLookups::SecondarySchoolCourseSelection).count}"
      puts "MasterSecondarySchool: #{ObjectSpace.each_object(MasterSecondarySchool).count}"
      puts "ActiveRecord: #{ObjectSpace.each_object(ActiveRecord::Base).count}"
      ActiveRecord::Base.logger = old_logger
      GC.enable
    end
  end

  def all_applicants
    Applicant.where("1=1")
  end

  def parse_coursework_report(raw_csv)
    CsvParser.new(raw_csv).to_hashes
  end
end