Last active
August 29, 2015 14:08
-
-
Save tborisova/796d9e518e79213e7733 to your computer and use it in GitHub Desktop.
New tests for homework 2 - Programming with Go
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package main | |
import ( | |
"fmt" | |
"reflect" | |
"testing" | |
) | |
type SusiTest struct { | |
students map[int][]byte | |
courses map[string][]byte | |
} | |
func newSusiTest() (*SusiTest, *Susi) { | |
st := new(SusiTest) | |
st.students = map[int][]byte{ | |
11111: []byte(`{"faculty_number":11111,"first_name":"Test","last_name":"One","master":false,"academic_year":1}`), | |
22222: []byte(`{"faculty_number":22222,"first_name":"Test","last_name":"Two","master":false,"academic_year":2}`), | |
33333: []byte(`{"faculty_number":33333,"first_name":"Test","last_name":"Three","master":false,"academic_year":3}`), | |
44444: []byte(`{"faculty_number":44444,"first_name":"Test","last_name":"Four","master":false,"academic_year":4}`), | |
55555: []byte(`{"faculty_number":55555,"first_name":"Test","last_name":"Master","master":true,"academic_year":0}`), | |
} | |
st.courses = map[string][]byte{ | |
"AR": []byte(`{"course_name":"Advanced Robotics","course_identifier":"AR","minimum_academic_year":3,"masters_only":false,"available_places":2}`), | |
"R101": []byte(`{"course_name":"Robotics 101","course_identifier":"R101","minimum_academic_year":1,"masters_only":false,"available_places":2}`), | |
"MO": []byte(`{"course_name":"Masters Only","course_identifier":"MO","minimum_academic_year":0,"masters_only":true,"available_places":2}`), | |
"FC": []byte(`{"course_name":"Full Course","course_identifier":"FC","minimum_academic_year":0,"masters_only":false,"available_places":0}`), | |
} | |
return st, NewSusi() | |
} | |
func (st *SusiTest) AddStudents(s *Susi, fns ...int) error { | |
for _, fn := range fns { | |
err := s.AddStudent(st.students[fn]) | |
if err != nil { | |
return err | |
} | |
} | |
return nil | |
} | |
func (st *SusiTest) AddCourses(s *Susi, identifiers ...string) error { | |
for _, identifier := range identifiers { | |
err := s.AddCourse(st.courses[identifier]) | |
if err != nil { | |
return err | |
} | |
} | |
return nil | |
} | |
func (st *SusiTest) Enroll(s *Susi, fn int, identifier string) error { | |
payload := []byte(fmt.Sprintf("{\"faculty_number\":%d,\"course_identifier\":\"%s\"}", fn, identifier)) | |
return s.Enroll(payload) | |
} | |
// Errors | |
func (st *SusiTest) studentCannotEnrollError(student *Student, course *Course) string { | |
return fmt.Sprintf("%s %s не покрива изискванията за %s!", student.FirstName, student.LastName, course.CourseName) | |
} | |
func (st *SusiTest) studentNotFoundError(fn int) string { | |
return fmt.Sprintf("Няма студент с факултетен номер %d!", fn) | |
} | |
func (st *SusiTest) studentAlreadyExistsError(fn int) string { | |
return fmt.Sprintf("Студент с факултетен номер %d вече съществува!", fn) | |
} | |
func (st *SusiTest) courseNotFoundError(identifier string) string { | |
return fmt.Sprintf("Няма курс с identifier - %s!", identifier) | |
} | |
func (st *SusiTest) courseAlreadyExistsError(identifier string) string { | |
return fmt.Sprintf("Курс с identifier %s вече съществува!", identifier) | |
} | |
func (st *SusiTest) courseIsFullError(identifier string) string { | |
return fmt.Sprintf("Няма свободни места за курс с identifier - %s!", identifier) | |
} | |
func (st *SusiTest) enrollmentAlreadyExistsError(fn int, identifier string) string { | |
return fmt.Sprintf("Студент с факултетен номер %d вече е записан за курс с identifier %s!", fn, identifier) | |
} | |
func (st *SusiTest) enrollmentNotFoundError(fn int, identifier string) string { | |
return fmt.Sprintf("Студент с факултетен номер %d не е записан за курса с identifier %s!", fn, identifier) | |
} | |
// Tests | |
func TestAddStudent(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddStudents(s, 11111) | |
if err != nil { | |
t.Errorf("Failed to add a student, recieved: %s!", err.Error()) | |
} | |
} | |
func TestFindMissingStudent(t *testing.T) { | |
st, s := newSusiTest() | |
_, err := s.FindStudent(22222) | |
if err == nil { | |
t.Error("Expected to recieve an error when getting an missing student!") | |
} | |
got := err.Error() | |
expected := st.studentNotFoundError(22222) | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestAddCourse(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddCourses(s, "AR") | |
if err != nil { | |
t.Errorf("Failed to add a course, recieved: %s!", err.Error()) | |
} | |
} | |
func TestEnroll(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddStudents(s, 11111, 22222) | |
if err != nil { | |
t.Errorf("Failed to add a student, recieved: %s!", err.Error()) | |
} | |
err = st.AddCourses(s, "AR", "R101", "FC") | |
if err != nil { | |
t.Errorf("Failed to add a course, recieved: %s!", err.Error()) | |
} | |
err = st.Enroll(s, 11111, "R101") | |
if err != nil { | |
t.Errorf("Failed to enroll in a course, recieved: %s", err.Error()) | |
} | |
err = st.Enroll(s, 22222, "R101") | |
if err != nil { | |
t.Errorf("Failed to enroll in a course, recieved: %s", err.Error()) | |
} | |
} | |
func TestEnrollMoreThanAvailablePlaces(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddStudents(s, 11111, 22222, 33333) | |
if err != nil { | |
t.Errorf("Failed to add a student, recieved: %s!", err.Error()) | |
} | |
err = st.AddCourses(s, "R101", "FC") | |
if err != nil { | |
t.Errorf("Failed to add a course, recieved: %s!", err.Error()) | |
} | |
err = st.Enroll(s, 11111, "R101") | |
if err != nil { | |
t.Errorf("Failed to enroll the first student, got: %s", err.Error()) | |
} | |
err = st.Enroll(s, 22222, "R101") | |
if err != nil { | |
t.Errorf("Failed to enroll the second student, got: %s", err.Error()) | |
} | |
err = st.Enroll(s, 33333, "R101") | |
if err == nil { | |
t.Error("Expected to recieve an error when enrolling the third student!") | |
} | |
got := err.Error() | |
expected := st.courseIsFullError("R101") | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestEnrollTwiceInTheSameCourseWithTheSameUser(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddStudents(s, 11111) | |
if err != nil { | |
t.Errorf("Failed to add a student, recieved: %s!", err.Error()) | |
} | |
err = st.AddCourses(s, "R101", "FC") | |
if err != nil { | |
t.Errorf("Failed to add a course, recieved: %s!", err.Error()) | |
} | |
err = st.Enroll(s, 11111, "R101") | |
if err != nil { | |
t.Errorf("Failed to enroll the first time, got: %s", err.Error()) | |
} | |
err = st.Enroll(s, 11111, "R101") | |
if err == nil { | |
t.Error("Expected to recieve an error when enrolling twise in the same course with the same user!") | |
} | |
got := err.Error() | |
expected := st.enrollmentAlreadyExistsError(11111, "R101") | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestEnrollWhenTheRequirementsAreNotMet(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddStudents(s, 11111) | |
if err != nil { | |
t.Errorf("Failed to add a student, recieved: %s!", err.Error()) | |
} | |
err = st.AddCourses(s, "R101", "AR") | |
if err != nil { | |
t.Errorf("Failed to add a course, recieved: %s!", err.Error()) | |
} | |
err = st.Enroll(s, 11111, "AR") | |
if err == nil { | |
t.Error("Expected to recieve an error when enrolling in a course where the student doesn't meet the requirements!") | |
} | |
student, _ := s.FindStudent(11111) | |
course, _ := s.FindCourse("AR") | |
got := err.Error() | |
expected := st.studentCannotEnrollError(student, course) | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestEnrollInMasterOnlyCourse(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddStudents(s, 11111, 55555) | |
if err != nil { | |
t.Errorf("Failed to add a student, recieved: %s!", err.Error()) | |
} | |
err = st.AddCourses(s, "MO", "AR") | |
if err != nil { | |
t.Errorf("Failed to add a course, recieved: %s!", err.Error()) | |
} | |
err = st.Enroll(s, 55555, "MO") | |
if err != nil { | |
t.Errorf("Failed to enroll in a master only course when the student is a master, recieved: %s!", err.Error()) | |
} | |
err = st.Enroll(s, 11111, "MO") | |
if err == nil { | |
t.Error("Expected to recieve an error when enrolling in a master only course where the student is not a master!") | |
} | |
student, _ := s.FindStudent(11111) | |
course, _ := s.FindCourse("MO") | |
got := err.Error() | |
expected := st.studentCannotEnrollError(student, course) | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestStudentImplementStringer(t *testing.T) { | |
st, s := newSusiTest() | |
_ = st.AddStudents(s, 11111, 22222) | |
student, _ := s.FindStudent(11111) | |
got := student.String() | |
expected := "11111 Test One" | |
if got != expected { | |
t.Errorf("Student#String failed! Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestCourseImplementStringer(t *testing.T) { | |
st, s := newSusiTest() | |
_ = st.AddCourses(s, "AR", "R101") | |
course, _ := s.FindCourse("AR") | |
got := course.String() | |
expected := "AR Advanced Robotics" | |
if got != expected { | |
t.Errorf("Course#String failed! Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestSusiErrorOnEnrollment(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddStudents(s, 11111, 55555) | |
err = st.AddCourses(s, "MO", "AR") | |
err = st.Enroll(s, 11111, "MO") | |
if err == nil { | |
t.Error("Expected to recieve an error") | |
} | |
student, _ := s.FindStudent(11111) | |
course, _ := s.FindCourse("MO") | |
errorType := reflect.TypeOf(err).String() | |
if errorType != "*main.SusiError" && errorType != "*SusiError" { | |
t.Errorf("Expected error to be *main.SusiError, but was: %s", errorType) | |
} | |
susiErr := err.(*SusiError) | |
if susiErr.Course != course { | |
t.Errorf("Expected susiErr.Course to be %V, but was %V", course, susiErr.Course) | |
} | |
if susiErr.Student != student { | |
t.Errorf("Expected susiErr.Student to be %V, but was %V", student, susiErr.Student) | |
} | |
} | |
// NEW TESTS | |
func TestAlreadyExistingStudent(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddStudents(s, 11111) | |
err = st.AddStudents(s, 11111) | |
if err == nil { | |
t.Error("Expected to recieve an error when adding existing student!") | |
} | |
got := err.Error() | |
expected := st.studentAlreadyExistsError(11111) | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestFindMissingCourse(t *testing.T) { | |
st, s := newSusiTest() | |
_, err := s.FindCourse("AR") | |
if err == nil { | |
t.Error("Expected to recieve an error when getting an missing course!") | |
} | |
got := err.Error() | |
expected := st.courseNotFoundError("AR") | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestAlreadyExistingCourse(t *testing.T) { | |
st, s := newSusiTest() | |
err := st.AddCourses(s, "MO") | |
err = st.AddCourses(s, "MO") | |
if err == nil { | |
t.Error("Expected to recieve an error when adding existing course!") | |
} | |
got := err.Error() | |
expected := st.courseAlreadyExistsError("MO") | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestMissingStudentOnNewEnrollment(t *testing.T) { | |
st, s := newSusiTest() | |
st.AddCourses(s, "MO", "AR") | |
err := st.Enroll(s, 55551, "MO") | |
if err == nil { | |
t.Error("Expected to recieve an error when enrolling missing student!") | |
} | |
got := err.Error() | |
expected := st.studentNotFoundError(55551) | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestMissingCourseOnNewEnrollment(t *testing.T) { | |
st, s := newSusiTest() | |
st.AddStudents(s, 11111) | |
err := st.Enroll(s, 11111, "MO") | |
if err == nil { | |
t.Errorf("Can't enroll a student to a missing course!") | |
} | |
got := err.Error() | |
expected := st.courseNotFoundError("MO") | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestCourseMissingOnFindEnrollment(t *testing.T) { | |
st, s := newSusiTest() | |
st.AddStudents(s, 11111) | |
st.AddCourses(s, "AR") | |
_, err := s.FindEnrollment(11111, "MO") | |
if err == nil { | |
t.Errorf("Can't find enrollment for a student to a missing course!") | |
} | |
got := err.Error() | |
expected := st.courseNotFoundError("MO") | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestStudentMissingOnFindEnrollment(t *testing.T) { | |
st, s := newSusiTest() | |
st.AddCourses(s, "AR") | |
_, err := s.FindEnrollment(11111, "AR") | |
if err == nil { | |
t.Error("Should have got error when looking for an enrollment with missing student!") | |
} | |
got := err.Error() | |
expected := st.studentNotFoundError(11111) | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} | |
func TestMissingEnrollmentOnFindEnrollment(t *testing.T) { | |
st, s := newSusiTest() | |
st.AddCourses(s, "AR") | |
st.AddStudents(s, 11111) | |
_, err := s.FindEnrollment(11111, "AR") | |
if err == nil { | |
t.Error("Expected to recieve an error when getting an missing enrollment!") | |
} | |
got := err.Error() | |
expected := st.enrollmentNotFoundError(11111, "AR") | |
if got != expected { | |
t.Errorf("Expected: %s, got: %s", expected, got) | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment