Add unit tests for api-tools/parser/parser.go #45

parser/courseParser.go

@@ -13,22 +13,29 @@ import (
 )
 
 var (
-	coursePrefixRexp *regexp.Regexp = utils.Regexpf(`^%s`, utils.R_SUBJ_COURSE_CAP)
-	contactRegexp    *regexp.Regexp = regexp.MustCompile(`\(([0-9]+)-([0-9]+)\)\s+([SUFY]+)`)
+	// coursePrefixRegexp matches the course prefix and number (e.g., "CS 1337").
+	coursePrefixRegexp = utils.Regexpf(`^%s`, utils.R_SUBJ_COURSE_CAP)
+
+	// contactRegexp matches the contact hours and offering frequency from the course description
+	// (e.g. "(12-34) SUS")
+	contactRegexp = regexp.MustCompile(`\(([0-9]+)-([0-9]+)\)\s+([SUFY]+)`)
 )
 
-func parseCourse(courseNum string, session schema.AcademicSession, rowInfo map[string]*goquery.Selection, classInfo map[string]string) *schema.Course {
+// parseCourse returns a pointer to the course specified by the
+// provided information. If the associated course is not found in
+// Courses, it will run getCourse and add the result to Courses.
+func parseCourse(internalCourseNumber string, session schema.AcademicSession, rowInfo map[string]*goquery.Selection, classInfo map[string]string) *schema.Course {
 	// Courses are internally keyed by their internal course number and the catalog year they're part of
 	catalogYear := getCatalogYear(session)
-	courseKey := courseNum + catalogYear
+	courseKey := internalCourseNumber + catalogYear
 
 	// Don't recreate the course if it already exists
 	course, courseExists := Courses[courseKey]
 	if courseExists {
 		return course
 	}
 
-	course = getCourse(courseNum, session, rowInfo, classInfo)
+	course = getCourse(internalCourseNumber, session, rowInfo, classInfo)
 
 	// Get closure for parsing course requisites (god help me)
 	enrollmentReqs, hasEnrollmentReqs := rowInfo["Enrollment Reqs:"]
@@ -39,8 +46,10 @@ func parseCourse(courseNum string, session schema.AcademicSession, rowInfo map[s
 	return course
 }
 
-// no global state is changed
-func getCourse(courseNum string, session schema.AcademicSession, rowInfo map[string]*goquery.Selection, classInfo map[string]string) *schema.Course {
+// getCourse extracts course details from the provided information and creates a schema.Course object.
+// This function does not modify any global state.
+// Returns a pointer to the newly created schema.Course object.
+func getCourse(internalCourseNumber string, session schema.AcademicSession, rowInfo map[string]*goquery.Selection, classInfo map[string]string) *schema.Course {
 	CoursePrefix, CourseNumber := getPrefixAndNumber(classInfo)
 
 	course := schema.Course{
@@ -54,7 +63,7 @@ func getCourse(courseNum string, session schema.AcademicSession, rowInfo map[str
 		Class_level:            classInfo["Class Level:"],
 		Activity_type:          classInfo["Activity Type:"],
 		Grading:                classInfo["Grading:"],
-		Internal_course_number: courseNum,
+		Internal_course_number: internalCourseNumber,
 		Catalog_year:           getCatalogYear(session),
 	}
 
@@ -70,6 +79,10 @@ func getCourse(courseNum string, session schema.AcademicSession, rowInfo map[str
 	return &course
 }
 
+// getCatalogYear determines the catalog year from the academic session information.
+// It assumes the session name starts with a 2-digit year and a semester character ('F', 'S', 'U').
+// Fall (S) and Summer U sessions are associated with the previous calendar year.
+// (e.g, 20F = 20, 20S = 19)
 func getCatalogYear(session schema.AcademicSession) string {
 	sessionYear, err := strconv.Atoi(session.Name[0:2])
 	if err != nil {
@@ -79,19 +92,20 @@ func getCatalogYear(session schema.AcademicSession) string {
 	switch sessionSemester {
 	case 'F':
 		return strconv.Itoa(sessionYear)
-	case 'S':
-		return strconv.Itoa(sessionYear - 1)
-	case 'U':
+	case 'S', 'U':
 		return strconv.Itoa(sessionYear - 1)
 	default:
 		panic(fmt.Errorf("encountered invalid session semester '%c!'", sessionSemester))
 	}
 }
 
+// getPrefixAndNumber returns the 2nd and 3rd matched values from a coursePrefixRegexp on
+// `classInfo["Class Section:"]`. It expects classInfo to contain "Class Section:" key.
+// If there are no matches, empty strings are returned.
 func getPrefixAndNumber(classInfo map[string]string) (string, string) {
 	if sectionId, ok := classInfo["Class Section:"]; ok {
 		// Get subject prefix and course number by doing a regexp match on the section id
-		matches := coursePrefixRexp.FindStringSubmatch(sectionId)
+		matches := coursePrefixRegexp.FindStringSubmatch(sectionId)
 		if len(matches) == 3 {
 			return matches[1], matches[2]
 		}

parser/courseParser_test.go

@@ -1,23 +1,23 @@
 package parser
 
 import (
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	"testing"
 
 	"github.com/UTDNebula/nebula-api/api/schema"
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
 )
 
 func TestGetCourse(t *testing.T) {
-	loadTestData(t)
+	t.Parallel()
 
-	for name, testCase := range testDataCache {
+	for name, testCase := range testData {
 		t.Run(name, func(t *testing.T) {
 			_, courseNum := getInternalClassAndCourseNum(testCase.ClassInfo)
 			output := *getCourse(courseNum, testCase.Section.Academic_session, testCase.RowInfo, testCase.ClassInfo)
 			expected := testCase.Course
 
-			diff := cmp.Diff(expected, output, cmpopts.IgnoreFields(schema.Course{}, "Id"))
+			diff := cmp.Diff(expected, output, cmpopts.IgnoreFields(schema.Course{}, "Id", "Sections", "Enrollment_reqs", "Prerequisites"))
 
 			if diff != "" {
 				t.Errorf("Failed (-expected +got)\n %s", diff)
@@ -28,46 +28,69 @@ func TestGetCourse(t *testing.T) {
 }
 
 func TestGetCatalogYear(t *testing.T) {
+	t.Parallel()
+
 	testCases := map[string]struct {
 		Session  schema.AcademicSession
 		Expected string
+		Panic    bool
 	}{
 		"Case_001": {
-			Session: schema.AcademicSession{
-				Name: "25S",
-			},
+			Session:  schema.AcademicSession{Name: "25S"},
 			Expected: "24",
-		}, "Case_002": {
-			Session: schema.AcademicSession{
-				Name: "25F",
-			},
+		},
+		"Case_002": {
+			Session:  schema.AcademicSession{Name: "25F"},
 			Expected: "25",
-		}, "Case_003": {
-			Session: schema.AcademicSession{
-				Name: "22U",
-			},
+		},
+		"Case_003": {
+			Session:  schema.AcademicSession{Name: "22U"},
 			Expected: "21",
-		}, "Case_004": {
-			Session: schema.AcademicSession{
-				Name: "20S",
-			},
+		},
+		"Case_004": {
+			Session:  schema.AcademicSession{Name: "20S"},
 			Expected: "19",
 		},
+		"Case_005": {
+			Session: schema.AcademicSession{Name: "Garbage"},
+			Panic:   true,
+		},
+		"Case_006": {
+			Session: schema.AcademicSession{Name: "20P"},
+			Panic:   true,
+		},
 	}
 
 	for name, tc := range testCases {
+		tc := tc // capture range variable
 		t.Run(name, func(t *testing.T) {
-			output := getCatalogYear(tc.Session)
+			t.Parallel()
+
+			defer func() {
+				// Test fails if we panic when we didn't want to or didn't when we did
+				if rec := recover(); rec != nil {
+					if !tc.Panic {
+						t.Errorf("unexpected panic for session %s: %v", tc.Session.Name, rec)
+					}
+				} else {
+					if tc.Panic {
+						t.Errorf("expected panic for session %s but got none", tc.Session.Name)
+					}
+				}
+			}()
 
-			if output != tc.Expected {
-				t.Errorf("expected %s got %s", tc.Expected, output)
+			// only call if we *expect* it to succeed
+			output := getCatalogYear(tc.Session)
+			if !tc.Panic && output != tc.Expected {
+				t.Errorf("expected %s, got %s", tc.Expected, output)
 			}
 		})
-
 	}
 }
 
 func TestGetPrefixAndCourseNum(t *testing.T) {
+	t.Parallel()
+
 	testCases := map[string]struct {
 		classInfo map[string]string
 		prefix    string

parser/parser.go

@@ -13,25 +13,33 @@ import (
 	"github.com/UTDNebula/nebula-api/api/schema"
 )
 
-// Main dictionaries for mapping unique keys to the actual data
-var Sections = make(map[primitive.ObjectID]*schema.Section)
-var Courses = make(map[string]*schema.Course)
-var Professors = make(map[string]*schema.Professor)
+var (
+	// Sections dictionary for mapping UUIDs to a *schema.Section
+	Sections = make(map[primitive.ObjectID]*schema.Section)
 
-// Auxilliary dictionaries for mapping the generated ObjectIDs to the keys used in the above maps, used for validation purposes
-var CourseIDMap = make(map[primitive.ObjectID]string)
-var ProfessorIDMap = make(map[primitive.ObjectID]string)
+	// Courses dictionary for keys (Internal_course_number +  Catalog_year) to a *schema.Course
+	Courses = make(map[string]*schema.Course)
 
-// Requisite parser closures associated with courses
-var ReqParsers = make(map[primitive.ObjectID]func())
+	// Professors dictionary for keys (First_name +   Last_name) to a *schema.Professor
+	Professors = make(map[string]*schema.Professor)
 
-// Grade mappings for section grade distributions, mapping is MAP[SEMESTER] -> MAP[SUBJECT + NUMBER + SECTION] -> GRADE DISTRIBUTION
-var GradeMap map[string]map[string][]int
+	//CourseIDMap auxiliary dictionary for mapping UUIDs to a *schema.Course
+	CourseIDMap = make(map[primitive.ObjectID]string)
 
-// Time location for dates (uses America/Chicago tz database zone for CDT which accounts for daylight saving)
-var timeLocation, timeError = time.LoadLocation("America/Chicago")
+	//ProfessorIDMap auxiliary dictionary for mapping UUIDs to a *schema.Professor
+	ProfessorIDMap = make(map[primitive.ObjectID]string)
 
-// Externally exposed parse function
+	// ReqParsers dictionary mapping course UUIDs to the func() that parsers its Reqs
+	ReqParsers = make(map[primitive.ObjectID]func())
+
+	// GradeMap mappings for section grade distributions, mapping is MAP[SEMESTER] -> MAP[SUBJECT + NUMBER + SECTION] -> GRADE DISTRIBUTION
+	GradeMap map[string]map[string][]int
+
+	// timeLocation Time location for dates (uses America/Chicago tz database zone for CDT which accounts for daylight saving)
+	timeLocation, timeError = time.LoadLocation("America/Chicago")
+)
+
+// Parse Externally exposed parse function
 func Parse(inDir string, outDir string, csvPath string, skipValidation bool) {
 
 	// Panic if timeLocation didn't load properly
@@ -91,7 +99,9 @@ func Parse(inDir string, outDir string, csvPath string, skipValidation bool) {
 	utils.WriteJSON(fmt.Sprintf("%s/professors.json", outDir), utils.GetMapValues(Professors))
 }
 
-// Internal parse function
+// parse is an internal helper function that parses a single HTML file.
+// It opens the file, creates a goquery document, and calls parseSection to
+// extract section data.
 func parse(path string) {
 
 	utils.VPrintf("Parsing %s...", path)
@@ -109,14 +119,14 @@ func parse(path string) {
 		panic(err)
 	}
 
-	// Dictionary to hold the row data, keyed by row header
-	rowInfo := getRowInfo(doc)
-	// Dictionary to hold the class info, keyed by data label
-	classInfo := getClassInfo(doc)
-
-	// Get the class and course num by splitting classInfo value
+	//recover from failing to parse a section
+	defer func() {
+		if r := recover(); r != nil {
+			utils.VPrintf("Recovered from panic, skipping section %s: %v", path, r)
+		}
+	}()
+	parseSection(getRowInfo(doc), getClassInfo(doc))
 
-	parseSection(rowInfo, classInfo)
 	utils.VPrint("Parsed!")
 }