testutils

package
v1.7.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 18, 2026 License: MIT Imports: 12 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	StartTime              = time.Now()
	TUMLiveContextStudent  = tools.TUMLiveContext{User: &Student}
	TUMLiveContextLecturer = tools.TUMLiveContext{User: &Lecturer}
	TUMLiveContextAdmin    = tools.TUMLiveContext{User: &Admin}
	TUMLiveContextUserNil  = tools.TUMLiveContext{User: nil}
	TUMLiveContextEmpty    = tools.TUMLiveContext{}
)

Misc

View Source 
var (
	Student          = model.User{Model: gorm.Model{ID: 42}, Role: model.StudentType, PinnedCourses: []model.Course{CourseFPV}}
	Lecturer         = model.User{Model: gorm.Model{ID: 31}, Role: model.LecturerType}
	Admin            = model.User{Model: gorm.Model{ID: 0}, Role: model.AdminType}
	EmptyLectureHall = model.LectureHall{}
	LectureHall      = model.LectureHall{
		Model:     gorm.Model{ID: uint(1)},
		Name:      "FMI_HS1",
		FullName:  "MI HS1",
		CombIP:    "127.0.0.1/extron3",
		PresIP:    "127.0.0.1/extron1",
		CamIP:     "127.0.0.1/extron2",
		CameraIP:  "127.0.0.1",
		RoomID:    0,
		PwrCtrlIp: "http://pwrctrlip.in.test.de",
	}
	CameraPreset = model.CameraPreset{
		Name:          "Home",
		PresetID:      1,
		Image:         "ccc47fae-847c-4a91-8a65-b26cbae6fbe2.jpg",
		LectureHallID: LectureHall.ID,
		IsDefault:     false,
	}
	CourseFPV = model.Course{
		Model:                gorm.Model{ID: uint(40)},
		UserID:               1,
		Name:                 "Funktionale Programmierung und Verifikation (IN0003)",
		Slug:                 "fpv",
		Year:                 2022,
		TeachingTerm:         "W",
		TUMOnlineIdentifier:  "2020",
		VODEnabled:           false,
		DownloadsEnabled:     false,
		ChatEnabled:          true,
		AnonymousChatEnabled: false,
		ModeratedChatEnabled: false,
		VodChatEnabled:       false,
		Visibility:           "public",
		Admins:               []model.User{Admin},
		Streams:              []model.Stream{StreamFPVLive, StreamFPVNotLive, SelfStream},
	}
	CourseGBS = model.Course{
		Model:                gorm.Model{ID: uint(42)},
		UserID:               1,
		Name:                 "Grundlagen: Betriebssysteme und Systemsoftware (IN0009)",
		Slug:                 "gbs",
		Year:                 0,
		TeachingTerm:         "W",
		TUMOnlineIdentifier:  "2021",
		VODEnabled:           false,
		DownloadsEnabled:     false,
		ChatEnabled:          true,
		AnonymousChatEnabled: false,
		ModeratedChatEnabled: false,
		VodChatEnabled:       false,
		Visibility:           "public",
	}
	CourseTensNet = model.Course{
		Model:                gorm.Model{ID: uint(55)},
		UserID:               1,
		Name:                 "Tensor Networks (IN2388)",
		Slug:                 "TensNet",
		Year:                 2023,
		TeachingTerm:         "S",
		TUMOnlineIdentifier:  "2023",
		VODEnabled:           false,
		DownloadsEnabled:     false,
		ChatEnabled:          true,
		AnonymousChatEnabled: false,
		ModeratedChatEnabled: false,
		VodChatEnabled:       false,
		Visibility:           "enrolled",
		Streams:              []model.Stream{StreamTensNetLive},
	}
	StreamFPVLive = model.Stream{
		Model:            gorm.Model{ID: 1969},
		Name:             "Lecture 1",
		Description:      "First official stream",
		CourseID:         40,
		Start:            StartTime,
		End:              StartTime.Add(time.Hour),
		ChatEnabled:      true,
		RoomName:         "00.08.038, Seminarraum",
		RoomCode:         "5608.EG.038",
		EventTypeName:    "Abhaltung",
		TUMOnlineEventID: 888261337,
		SeriesIdentifier: "e00a5d01-c530-41c5-8698-e40ec6d828ef",
		StreamKey:        "0dc3d-1337-1194-38f8-1337-7f16-bbe1-1337",
		PlaylistUrl:      "https://url",
		PlaylistUrlPRES:  "https://url",
		PlaylistUrlCAM:   "https://url",
		LiveNow:          true,
		LectureHallID:    LectureHall.ID,
		Files:            []model.File{Attachment, AttachmentInvalidPath},
		Units: []model.StreamUnit{
			{
				Model:           gorm.Model{ID: 1},
				UnitName:        "Unit 1",
				UnitDescription: "First unit",
				UnitStart:       0,
				UnitEnd:         1111,
				StreamID:        1969,
			},
		},
		VideoSections: []model.VideoSection{
			{
				Description:  "Introduction",
				StartHours:   0,
				StartMinutes: 0,
				StartSeconds: 0,
			},
			{
				Description:  "Proofs",
				StartHours:   1,
				StartMinutes: 33,
				StartSeconds: 7,
			},
		},
	}
	StreamFPVNotLive = model.Stream{
		Model:            gorm.Model{ID: 1969},
		Name:             "Lecture 1",
		Description:      "First official stream",
		CourseID:         40,
		Start:            StartTime,
		End:              StartTime.Add(time.Hour),
		ChatEnabled:      true,
		RoomName:         "00.08.038, Seminarraum",
		RoomCode:         "5608.EG.038",
		EventTypeName:    "Abhaltung",
		TUMOnlineEventID: 888261337,
		SeriesIdentifier: "e00a5d01-c530-41c5-8698-e40ec6d828ef",
		StreamKey:        "0dc3d-1337-1194-38f8-1337-7f16-bbe1-1337",
		PlaylistUrl:      "https://url",
		PlaylistUrlPRES:  "https://url",
		PlaylistUrlCAM:   "https://url",
		LiveNow:          false,
		LectureHallID:    LectureHall.ID,
	}
	StreamTensNetLive = model.Stream{
		Model:       gorm.Model{ID: 3333},
		Name:        "Tensor Contraction",
		Description: "C = A . B",
		CourseID:    55,
		Start:       time.Time{},
		End:         time.Time{},
		LiveNow:     true,
	}
	StreamGBSLive = model.Stream{
		Model:            gorm.Model{ID: 96},
		Name:             "Linker & Loader",
		Description:      "Tweedback: ...",
		CourseID:         CourseGBS.ID,
		Start:            StartTime,
		End:              StartTime.Add(time.Hour),
		ChatEnabled:      true,
		TUMOnlineEventID: 888333337,
		SeriesIdentifier: "",
		StreamKey:        "0dc3d-1337-7331-4201-1337-7f16-bbe1-2222",
		PlaylistUrl:      "https://url",
		PlaylistUrlPRES:  "https://url",
		PlaylistUrlCAM:   "https://url",
		LiveNow:          true,
	}
	SelfStream = model.Stream{
		Model:            gorm.Model{ID: 420},
		Name:             "Selfstream1",
		Description:      "First selfstream",
		CourseID:         40,
		Start:            StartTime,
		End:              StartTime.Add(time.Hour),
		ChatEnabled:      true,
		TUMOnlineEventID: 888261337,
		SeriesIdentifier: "",
		StreamKey:        "0dc3d-1337-1194-38f8-1337-7f16-bbe1-1111",
		PlaylistUrl:      "https://url",
		PlaylistUrlPRES:  "https://url",
		PlaylistUrlCAM:   "https://url",
		LiveNow:          false,
	}
	Worker1 = model.Worker{
		WorkerID: "ed067fa3-2364-4dcd-bfd2-e0ffb8d751d4",
		Host:     "localhost",
		Status:   "",
		Workload: 0,
		LastSeen: time.Now(),
	}
	Worker2 = model.Worker{
		WorkerID: "ed067fa3-2364-4dcd-bfd2-e0ffb8d751d4",
		Host:     "localhost",
		Status:   "",
		Workload: 0,
		LastSeen: time.Now(),
	}
	AdminToken = model.Token{
		UserID: Admin.ID,
		User:   Admin,
		Token:  "ed067f11-1337-4dcd-bfd2-4201b8d751d4",
		Scope:  model.TokenScopeAdmin,
	}
	Attachment = model.File{
		StreamID: 1969,
		Path:     "/tmp/test.txt",
		Filename: "test.txt",
		Type:     model.FILETYPE_ATTACHMENT,
	}
	AttachmentInvalidPath = model.File{
		StreamID: 1969,
		Path:     "/tmp/i_do_not_exist.txt",
		Filename: "i_do_not_exist.txt",
		Type:     model.FILETYPE_ATTACHMENT,
	}
	InfoPage = model.InfoPage{
		Model:      gorm.Model{ID: 1},
		Name:       "Data Privacy",
		RawContent: "#data privacy",
		Type:       model.INFOPAGE_MARKDOWN,
	}
	FPVNotLiveVideoSeekChunk1 = model.VideoSeekChunk{
		ChunkIndex: 1,
		StreamID:   StreamFPVNotLive.ID,
		Hits:       247,
	}
	FPVNotLiveVideoSeekChunk2 = model.VideoSeekChunk{
		ChunkIndex: 2,
		StreamID:   StreamFPVNotLive.ID,
		Hits:       112,
	}
	FPVNotLiveVideoSeekChunk3 = model.VideoSeekChunk{
		ChunkIndex: 3,
		StreamID:   StreamFPVNotLive.ID,
		Hits:       788,
	}
	Bookmark = model.Bookmark{
		Model:       gorm.Model{ID: 1},
		Description: "Klausurrelevant",
		Hours:       1,
		Minutes:     33,
		Seconds:     7,
		UserID:      Student.ID,
		StreamID:    StreamFPVLive.ID,
	}
	PollStreamFPVLive = model.Poll{
		Model:    gorm.Model{ID: uint(3)},
		StreamID: StreamFPVLive.ID,
		Stream:   StreamFPVLive,
		Question: "1+1=?",
		Active:   true,
		PollOptions: []model.PollOption{
			{Model: gorm.Model{ID: 0}, Answer: "2", Votes: []model.User{Student}},
			{Model: gorm.Model{ID: 1}, Answer: "3", Votes: []model.User{}},
		},
	}
	SubtitlesFPVLive = model.Subtitles{
		StreamID: StreamFPVLive.ID,
		Content:  "wonderful",
		Language: "en",
	}
)

Models

View Source 
var (
	HiddenCourseID   = uint(400)
	EnrolledCourseID = uint(401)
	LoggedinCourseID = uint(402)
	PublicCourseID   = uint(403)

	StreamIDHiddenCourse          = uint(500)
	StreamIDEnrolledCourse        = uint(510)
	StreamIDLoggedinCourse        = uint(520)
	StreamIDPublicCourse          = uint(530)
	PrivateStreamIDHiddenCourse   = uint(501)
	PrivateStreamIDEnrolledCourse = uint(511)
	PrivateStreamIDLoggedinCourse = uint(521)
	PrivateStreamIDPublicCourse   = uint(531)

	SubtitlesIDPublicCourseStream          = "1000"
	SubtitlesIDPublicCoursePrivateStream   = "1001"
	SubtitlesIDLoggedinCourseStream        = "1002"
	SubtitlesIDLoggedinCoursePrivateStream = "1003"
	SubtitlesIDEnrolledCourseStream        = "1004"
	SubtitlesIDEnrolledCoursePrivateStream = "1005"
	SubtitlesIDHiddenCourseStream          = "1006"
	SubtitlesIDHiddenCoursePrivateStream   = "1007"
)

testdata for testing the search functionality ids

View Source 
var (
	TUMLiveContextLecturerNoCourseSearch   = tools.TUMLiveContext{User: &LecturerNoCourse}
	TUMLiveContextLecturerAllCoursesSearch = tools.TUMLiveContext{User: &LecturerAllCourses}
	TUMLiveContextStudentNoCourseSearch    = tools.TUMLiveContext{User: &StudentNoCourse}
	TUMLiveContextStudentAllCoursesSearch  = tools.TUMLiveContext{User: &StudentAllCourses}
)

TUMLiveContext for search tests

View Source 
var (
	// users
	LecturerNoCourse = model.User{
		Model:               gorm.Model{ID: 610},
		Role:                model.LecturerType,
		Courses:             []model.Course{},
		AdministeredCourses: []model.Course{},
	}
	LecturerAllCourses = model.User{
		Model:               gorm.Model{ID: 611},
		Role:                model.LecturerType,
		Courses:             []model.Course{},
		AdministeredCourses: []model.Course{HiddenCourse, EnrolledCourse, LoggedinCourse, PublicCourse},
	}
	StudentNoCourse = model.User{
		Model:   gorm.Model{ID: 620},
		Role:    model.StudentType,
		Courses: []model.Course{},
	}
	StudentAllCourses = model.User{
		Model:   gorm.Model{ID: 621},
		Role:    model.StudentType,
		Courses: []model.Course{HiddenCourse, EnrolledCourse, LoggedinCourse, PublicCourse},
	}

	// courses
	AllCoursesForSearchTests = []model.Course{HiddenCourse, EnrolledCourse, LoggedinCourse, PublicCourse}

	HiddenCourse = model.Course{
		Model:        gorm.Model{ID: HiddenCourseID},
		UserID:       1,
		Name:         "testen",
		Slug:         "coursehidden",
		Year:         2024,
		TeachingTerm: "W",
		Visibility:   "hidden",
		Streams:      []model.Stream{StreamHiddenCourse, PrivateStreamHiddenCourse},
		Admins:       []model.User{},
	}
	EnrolledCourse = model.Course{
		Model:        gorm.Model{ID: EnrolledCourseID},
		UserID:       1,
		Name:         "testen",
		Slug:         "courseenrolled",
		Year:         2024,
		TeachingTerm: "W",
		Visibility:   "enrolled",
		Streams:      []model.Stream{StreamEnrolledCourse, PrivateStreamEnrolledCourse},
		Admins:       []model.User{},
	}
	LoggedinCourse = model.Course{
		Model:        gorm.Model{ID: LoggedinCourseID},
		UserID:       1,
		Name:         "testen",
		Slug:         "courseloggedin",
		Year:         2024,
		TeachingTerm: "W",
		Visibility:   "loggedin",
		Streams:      []model.Stream{StreamLoggedinCourse, PrivateStreamLoggedinCourse},
		Admins:       []model.User{},
	}
	PublicCourse = model.Course{
		Model:        gorm.Model{ID: PublicCourseID},
		UserID:       1,
		Name:         "testen",
		Slug:         "coursepublic",
		Year:         2024,
		TeachingTerm: "W",
		Visibility:   "public",
		Streams:      []model.Stream{StreamPublicCourse, PrivateStreamPublicCourse},
		Admins:       []model.User{},
	}

	// streans
	AllStreamsForSearchTests = []model.Stream{StreamHiddenCourse, PrivateStreamHiddenCourse, StreamEnrolledCourse, PrivateStreamEnrolledCourse, StreamLoggedinCourse, PrivateStreamLoggedinCourse, StreamPublicCourse, PrivateStreamPublicCourse}

	StreamHiddenCourse = model.Stream{
		Model:       gorm.Model{ID: StreamIDHiddenCourse},
		Name:        "testen",
		Description: "testen",
		CourseID:    400,
		Recording:   true,
		Private:     false,
	}
	PrivateStreamHiddenCourse = model.Stream{
		Model:       gorm.Model{ID: PrivateStreamIDHiddenCourse},
		Name:        "testen",
		Description: "testen",
		CourseID:    400,
		Recording:   true,
		Private:     true,
	}
	StreamEnrolledCourse = model.Stream{
		Model:       gorm.Model{ID: StreamIDEnrolledCourse},
		Name:        "testen",
		Description: "testen",
		CourseID:    401,
		Recording:   true,
		Private:     false,
	}
	PrivateStreamEnrolledCourse = model.Stream{
		Model:       gorm.Model{ID: PrivateStreamIDEnrolledCourse},
		Name:        "testen",
		Description: "testen",
		CourseID:    401,
		Recording:   true,
		Private:     true,
	}
	StreamLoggedinCourse = model.Stream{
		Model:       gorm.Model{ID: StreamIDLoggedinCourse},
		Name:        "testen",
		Description: "testen",
		CourseID:    402,
		Recording:   true,
		Private:     false,
	}
	PrivateStreamLoggedinCourse = model.Stream{
		Model:       gorm.Model{ID: PrivateStreamIDLoggedinCourse},
		Name:        "testen",
		Description: "testen",
		CourseID:    402,
		Recording:   true,
		Private:     true,
	}
	StreamPublicCourse = model.Stream{
		Model:       gorm.Model{ID: StreamIDPublicCourse},
		Name:        "testen",
		Description: "testen",
		CourseID:    403,
		Recording:   true,
		Private:     false,
	}
	PrivateStreamPublicCourse = model.Stream{
		Model:       gorm.Model{ID: PrivateStreamIDPublicCourse},
		Name:        "testen",
		Description: "testen",
		CourseID:    403,
		Recording:   true,
		Private:     true,
	}

	// subtitles
	AllSubtitlesForSearchTests  = []tools.MeiliSubtitles{SubtitlesStreamHiddenCourse, SubtitlesPrivateStreamHiddenCourse, SubtitlesStreamEnrolledCourse, SubtitlesPrivateStreamEnrolledCourse, SubtitlesStreamLoggedinCourse, SubtitlesPrivateStreamLoggedinCourse, SubtitlesStreamPublicCourse, SubtitlesPrivateStreamPublicCourse}
	SubtitlesStreamPublicCourse = tools.MeiliSubtitles{
		ID:       SubtitlesIDPublicCourseStream,
		StreamID: StreamIDPublicCourse,
		Text:     "hallihallo1",
	}
	SubtitlesPrivateStreamPublicCourse = tools.MeiliSubtitles{
		ID:       SubtitlesIDPublicCoursePrivateStream,
		StreamID: PrivateStreamIDPublicCourse,
		Text:     "hallihallo2",
	}
	SubtitlesStreamLoggedinCourse = tools.MeiliSubtitles{
		ID:       SubtitlesIDLoggedinCourseStream,
		StreamID: StreamIDLoggedinCourse,
		Text:     "hallihallo1",
	}
	SubtitlesPrivateStreamLoggedinCourse = tools.MeiliSubtitles{
		ID:       SubtitlesIDLoggedinCoursePrivateStream,
		StreamID: PrivateStreamIDLoggedinCourse,
		Text:     "hallihallo2",
	}
	SubtitlesStreamEnrolledCourse = tools.MeiliSubtitles{
		ID:       SubtitlesIDEnrolledCourseStream,
		StreamID: StreamIDEnrolledCourse,
		Text:     "hallihallo1",
	}
	SubtitlesPrivateStreamEnrolledCourse = tools.MeiliSubtitles{
		ID:       SubtitlesIDEnrolledCoursePrivateStream,
		StreamID: PrivateStreamIDEnrolledCourse,
		Text:     "hallihallo2",
	}
	SubtitlesStreamHiddenCourse = tools.MeiliSubtitles{
		ID:       SubtitlesIDHiddenCourseStream,
		StreamID: StreamIDHiddenCourse,
		Text:     "hallihallo1",
	}
	SubtitlesPrivateStreamHiddenCourse = tools.MeiliSubtitles{
		ID:       SubtitlesIDHiddenCoursePrivateStream,
		StreamID: PrivateStreamIDHiddenCourse,
		Text:     "hallihallo2",
	}
)

Functions

func CreateVideoSeekData 

func CreateVideoSeekData(streamId uint, chunkCount int) ([]model.VideoSeekChunk, gin.H)

CreateVideoSeekData returns list of generated VideoSeekChunk and expected response object

func Equal 

func Equal(t *testing.T, a, b interface{})

func GetAuditMock 

func GetAuditMock(t *testing.T) dao.AuditDao

func GetCoursesMock 

func GetCoursesMock(t *testing.T) dao.CoursesDao

func GetFileMock 

func GetFileMock(t *testing.T) dao.FileDao

func GetLectureHallMock 

func GetLectureHallMock(t *testing.T) dao.LectureHallsDao

func GetMiddlewares 

func GetMiddlewares(mw ...func(ctx *gin.Context)) []func(c *gin.Context)

func GetStreamMock 

func GetStreamMock(t *testing.T) dao.StreamsDao

func GetTokenMock 

func GetTokenMock(t *testing.T) dao.TokenDao

func GetUploadKeyMock 

func GetUploadKeyMock(t *testing.T) dao.UploadKeyDao

func GetUsersMock 

func GetUsersMock(t *testing.T) dao.UsersDao

func TUMLiveContext 

func TUMLiveContext(ctx tools.TUMLiveContext) func(c *gin.Context)

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.