blackicedbear/FHC-Core
1
0
Fork 0
mirror of https://github.com/FH-Complete/FHC-Core.git synced 2026-10-12 15:04:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed CY tests

Browse Source
This commit is contained in:
Paolo
2026-08-11 15:30:59 +02:00
parent 5f34a6d38a
commit 5df31a7fbc
5 changed files with 96 additions and 755 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/cypress/cypress/e2e/specs/api/rolesinroles/roles.cy.js
+8 -726
View File
@@ -1,736 +1,18 @@
import { tempusApi } from "../../../../support/api/tempusApi";
import {
getTempusTestSemester,
TEMPUS_TEST_STUDY_PLAN_SHORT_CODE,
} from "../../../../support/helpers/tempusTestData";
import { rolesinrolesApi } from "../../../../support/api/rolesinrolesApi";
let TEMPUS_TEST_SEMESTER;
describe("Tempus Kalender API", () => {
before(() => {
cy.login();
getTempusTestSemester().then((semester) => {
TEMPUS_TEST_SEMESTER = semester;
});
});
describe("Roles in roles checks", () => {
beforeEach(() => {
cy.login();
tempusApi.resetTempusScenario();
});
it("event creation works for non collision case", () => {
tempusApi.getStudyPlansTree().then((stgTree) => {
let studyPlan = stgTree.find((plan) =>
plan.name.includes(TEMPUS_TEST_STUDY_PLAN_SHORT_CODE),
);
expect(studyPlan, "study plan for test event creation").to.exist;
tempusApi
.getCoursesByStudyPlan(studyPlan.studiengang_kz, TEMPUS_TEST_SEMESTER)
.then((courses) => {
let course = courses.find((course) => course.lehrfach === "MAT");
expect(course, "course for test event creation").to.exist;
tempusApi
.updateSettingsData(tempusApi.getSettingsData())
.then((response) => {
const lehreinheitId = course.lehreinheit_id[0];
expect(lehreinheitId, "lehreinheit id for test event creation").to
.exist;
const startDateTime = `${getDateForDay("monday")} 17:50`;
const endDateTime = `${getDateForDay("monday")} 18:35`;
tempusApi
.createKalenderEvent(lehreinheitId, startDateTime, endDateTime)
.then((response) => {
expect(response.status).to.eq(200);
expect(response.body).to.have.nested.property(
"meta.status",
"success",
);
});
});
});
});
it("checks permission agains the main role", () => {
rolesinrolesApi.permissionToMainRole();
});
it("prohibited event creation due to zeitsperre collision", () => {
tempusApi.getStudyPlansTree().then((stgTree) => {
let studyPlan = stgTree.find((plan) =>
plan.name.includes(TEMPUS_TEST_STUDY_PLAN_SHORT_CODE),
);
expect(studyPlan, "study plan for test event creation").to.exist;
tempusApi
.getCoursesByStudyPlan(studyPlan.studiengang_kz, TEMPUS_TEST_SEMESTER)
.then((courses) => {
let course = courses.find((course) =>
course.lektoren.some((lector) => lector.kurzbz === "DemoLKT1"),
);
expect(course, "course for test event creation").to.exist;
tempusApi
.updateSettingsData(tempusApi.getSettingsData())
.then((response) => {
const lehreinheitId = course.lehreinheit_id[0];
expect(lehreinheitId, "lehreinheit id for test event creation").to
.exist;
const startDateTime = `${getDateForDay("saturday")} 18:35`;
const endDateTime = `${getDateForDay("saturday")} 19:20`;
tempusApi
.createKalenderEvent(lehreinheitId, startDateTime, endDateTime)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasTimeLockCollisionError = response.body.errors.some(
(error) => error.errorCode === "absences_collision",
);
expect(
hasTimeLockCollisionError,
"response contains time lock collision error",
).to.be.true;
});
});
});
});
it("checks permission agains the basic role", () => {
rolesinrolesApi.permissionToBasicRole();
});
it("prohibited event creation due to student group collision", () => {
tempusApi.getStudyPlansTree().then((stgTree) => {
let studyPlan = stgTree.find((plan) =>
plan.name.includes(TEMPUS_TEST_STUDY_PLAN_SHORT_CODE),
);
expect(studyPlan, "study plan for test event creation").to.exist;
tempusApi
.getCoursesByStudyPlan(studyPlan.studiengang_kz, TEMPUS_TEST_SEMESTER)
.then((courses) => {
let course = courses.find(
(course) =>
course.lehrfach === "ENG" &&
course.lektoren.some((lector) => lector.kurzbz === "DemoLKT3"),
);
expect(course, "course for test event creation").to.exist;
tempusApi
.updateSettingsData(tempusApi.getSettingsData())
.then((response) => {
const lehreinheitId = course.lehreinheit_id[0];
expect(lehreinheitId, "lehreinheit id for test event creation").to
.exist;
const startDateTime = `${getDateForDay("wednesday")} 18:35`;
const endDateTime = `${getDateForDay("wednesday")} 19:20`;
tempusApi
.createKalenderEvent(lehreinheitId, startDateTime, endDateTime)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasStudentGroupCollisionError = response.body.errors.some(
(error) => error.errorCode === "verband_collision",
);
expect(
hasStudentGroupCollisionError,
"response contains student collision error",
).to.be.true;
});
});
});
});
});
it("prohibited event creation due to direct student collision", () => {
let settingsData = tempusApi.getSettingsData();
settingsData.kollision_student = true;
tempusApi.getStudyPlansTree().then((stgTree) => {
let studyPlan = stgTree.find((plan) =>
plan.name.includes(TEMPUS_TEST_STUDY_PLAN_SHORT_CODE),
);
expect(studyPlan, "study plan for test event creation").to.exist;
tempusApi
.getCoursesByStudyPlan(studyPlan.studiengang_kz, TEMPUS_TEST_SEMESTER)
.then((courses) => {
let course = courses.find(
(course) =>
course.lehrfach === "ENG" &&
course.lektoren.some((lector) => lector.kurzbz === "DemoLKT3"),
);
expect(course, "course for test event creation").to.exist;
tempusApi.updateSettingsData(settingsData).then((response) => {
tempusApi
.getPlannerEvents(
getDateForDay("monday"),
getDateForDay("monday"),
)
.then((events) => {
const lehreinheitId = course.lehreinheit_id[0];
expect(lehreinheitId, "lehreinheit id for test event creation")
.to.exist;
const startDateTime = `${getDateForDay("wednesday")} 18:35`;
const endDateTime = `${getDateForDay("wednesday")} 19:20`;
tempusApi
.createKalenderEvent(
lehreinheitId,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasStudentCollisionError = response.body.errors.some(
(error) => error.errorCode === "student_collision",
);
expect(
hasStudentCollisionError,
"response contains student collision error",
).to.be.true;
});
});
});
});
});
});
it("prohibited event creation due to lector collision", () => {
tempusApi.getStudyPlansTree().then((stgTree) => {
let studyPlan = stgTree.find((plan) =>
plan.name.includes(TEMPUS_TEST_STUDY_PLAN_SHORT_CODE),
);
expect(studyPlan, "study plan for test event creation").to.exist;
tempusApi
.getCoursesByStudyPlan(studyPlan.studiengang_kz, TEMPUS_TEST_SEMESTER)
.then((courses) => {
let course = courses.find((course) =>
course.lektoren.some((lector) => lector.kurzbz === "DemoLKT4"),
);
expect(course, "course for test event creation").to.exist;
tempusApi
.updateSettingsData(tempusApi.getSettingsData())
.then((response) => {
tempusApi
.getPlannerEvents(
getDateForDay("monday"),
getDateForDay("monday"),
)
.then((events) => {
const lehreinheitId = course.lehreinheit_id[0];
expect(
lehreinheitId,
"lehreinheit id for test event creation",
).to.exist;
const startDateTime = `${getDateForDay("thursday")} 18:35`;
const endDateTime = `${getDateForDay("thursday")} 19:20`;
tempusApi
.createKalenderEvent(
lehreinheitId,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasLectorCollisionError = response.body.errors.some(
(error) => error.errorCode === "lector_collision",
);
expect(
hasLectorCollisionError,
"response contains lector collision error",
).to.be.true;
});
});
});
});
});
});
it("event update works for non collision case", () => {
tempusApi
.updateSettingsData(tempusApi.getSettingsData())
.then((response) => {
tempusApi
.getPlannerEvents(getDateForDay("tuesday"), getDateForDay("tuesday"))
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.type === "lehreinheit" &&
event.beginn === "19:30:00" &&
event.ende === "20:15:00",
);
expect(
sourceEvent,
"source event without collision for update test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 20:15`;
const endDateTime = `${sourceEvent.datum} 21:00`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(200);
expect(response.body).to.have.nested.property(
"meta.status",
"success",
);
});
});
});
});
it("prohibited event update due to room collision", () => {
tempusApi
.updateSettingsData(tempusApi.getSettingsData())
.then((response) => {
tempusApi
.getPlannerEvents(
getDateForDay("wednesday"),
getDateForDay("wednesday"),
)
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.type === "lehreinheit" &&
event.beginn === "19:30:00" &&
event.ende === "20:15:00",
);
expect(
sourceEvent,
"source event with fixed time and room for collision test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 20:15`;
const endDateTime = `${sourceEvent.datum} 21:00`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasRoomCollisionError = response.body.errors.some(
(error) => error.errorCode === "room_collision",
);
expect(
hasRoomCollisionError,
"response contains room collision error",
).to.be.true;
});
});
});
});
it("prohibited event update due to student group collision", () => {
tempusApi
.updateSettingsData(tempusApi.getSettingsData())
.then((response) => {
tempusApi
.getPlannerEvents(
getDateForDay("thursday"),
getDateForDay("thursday"),
)
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.type === "lehreinheit" &&
event.beginn === "19:30:00" &&
event.ende === "20:15:00",
);
expect(
sourceEvent,
"source event with fixed time and room for collision test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 20:15`;
const endDateTime = `${sourceEvent.datum} 21:00`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasStudentGroupCollisionError = response.body.errors.some(
(error) => error.errorCode === "verband_collision",
);
expect(
hasStudentGroupCollisionError,
"response contains student group collision error",
).to.be.true;
});
});
});
});
it("prohibited event update due to direct student collision", () => {
let settingsData = tempusApi.getSettingsData();
settingsData.kollision_student = true;
tempusApi.updateSettingsData(settingsData).then((response) => {
tempusApi
.getPlannerEvents(getDateForDay("friday"), getDateForDay("friday"))
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.type === "lehreinheit" &&
event.beginn === "19:30:00" &&
event.ende === "20:15:00",
);
expect(
sourceEvent,
"source event with fixed time and room for collision test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 20:15`;
const endDateTime = `${sourceEvent.datum} 21:00`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasDirectStudentCollisionError = response.body.errors.some(
(error) => error.errorCode === "student_collision",
);
expect(
hasDirectStudentCollisionError,
"response contains student collision error",
).to.be.true;
});
});
});
});
it("prohibited event update due to lector collision", () => {
let settingsData = tempusApi.getSettingsData();
settingsData.kollision_student = false;
tempusApi.updateSettingsData(settingsData).then((response) => {
tempusApi
.getPlannerEvents(getDateForDay("saturday"), getDateForDay("saturday"))
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.type === "lehreinheit" &&
event.beginn === "19:30:00" &&
event.ende === "20:15:00",
);
expect(
sourceEvent,
"source event with fixed time and room for collision test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 20:15`;
const endDateTime = `${sourceEvent.datum} 21:00`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasLectorCollisionError = response.body.errors.some(
(error) => error.errorCode === "lector_collision",
);
expect(
hasLectorCollisionError,
"response contains lector collision error",
).to.be.true;
});
});
});
});
it("prohibited event update due to lector - zeitsperre collision", () => {
let settingsData = tempusApi.getSettingsData();
settingsData.kollision_student = false;
tempusApi.updateSettingsData(settingsData).then((response) => {
tempusApi
.getPlannerEvents(getDateForDay("friday"), getDateForDay("friday"))
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.type === "lehreinheit" &&
event.beginn === "19:30:00" &&
event.ende === "20:15:00" &&
event.lektor.some((lector) => lector.kurzbz === "DemoLKT1"),
);
expect(
sourceEvent,
"source event with fixed time and room for collision test",
).to.exist;
const startDateTime = `${getDateForDay("saturday")} 20:15`;
const endDateTime = `${getDateForDay("saturday")} 21:00`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasTimeLockCollisionError = response.body.errors.some(
(error) => error.errorCode === "absences_collision",
);
expect(
hasTimeLockCollisionError,
"response contains time lock collision error",
).to.be.true;
});
});
});
});
it("event update works for entries without collision", () => {
let settingsData = tempusApi.getSettingsData();
tempusApi.updateSettingsData(settingsData).then((response) => {
tempusApi
.getPlannerEvents(getDateForDay("sunday"), getDateForDay("sunday"))
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.beginn === "17:50:00" &&
event.ende === "18:35:00" &&
event.lektor.some((lector) => lector.kurzbz === "DemoLKT1"),
);
expect(
sourceEvent,
"source event with fixed time and resources for collision test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 18:35`;
const endDateTime = `${sourceEvent.datum} 19:20`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
console.log(response);
expect(response.status).to.eq(200);
expect(response.body).to.have.nested.property(
"meta.status",
"success",
);
});
});
});
});
it("prohibited event update due to resources collision", () => {
let settingsData = tempusApi.getSettingsData();
tempusApi.updateSettingsData(settingsData).then((response) => {
tempusApi
.getPlannerEvents(getDateForDay("sunday"), getDateForDay("sunday"))
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.beginn === "19:30:00" &&
event.ende === "20:15:00" &&
event.lektor.some((lector) => lector.kurzbz === "DemoLKT4"),
);
expect(
sourceEvent,
"source event with fixed time and resources for collision test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 20:15`;
const endDateTime = `${sourceEvent.datum} 21:00`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
console.log(response);
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasResourcesCollisionError = response.body.errors.some(
(error) => error.errorCode === "resource_collision",
);
expect(
hasResourcesCollisionError,
"response contains resources collision error",
).to.be.true;
});
});
});
});
it("prohibited event update due to lector - reservation collision", () => {
let settingsData = tempusApi.getSettingsData();
settingsData.kollision_student = false;
tempusApi.updateSettingsData(settingsData).then((response) => {
tempusApi
.getPlannerEvents(getDateForDay("saturday"), getDateForDay("saturday"))
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.type === "lehreinheit" &&
event.beginn === "19:30:00" &&
event.ende === "20:15:00" &&
event.lektor.some((lector) => lector.kurzbz === "DemoLKT4"),
);
expect(
sourceEvent,
"source event with fixed time and room for collision test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 20:15`;
const endDateTime = `${sourceEvent.datum} 21:00`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasReservationCollisionError = response.body.errors.some(
(error) => error.errorCode === "reservation_collision",
);
expect(
hasReservationCollisionError,
"response contains reservation collision error",
).to.be.true;
});
});
});
});
it("prohibited reservation update due to reservation - lector collision", () => {
let settingsData = tempusApi.getSettingsData();
settingsData.kollision_student = false;
tempusApi.updateSettingsData(settingsData).then((response) => {
tempusApi
.getPlannerEvents(getDateForDay("saturday"), getDateForDay("saturday"))
.then((events) => {
const sourceEvent = events.find(
(event) =>
event.type === "reservierung" &&
event.beginn === "20:15:00" &&
event.ende === "21:00:00" &&
event.lektor.some((lector) => lector.kurzbz === "DemoLKT1"),
);
expect(
sourceEvent,
"source event with fixed time and room for collision test",
).to.exist;
const startDateTime = `${sourceEvent.datum} 19:30`;
const endDateTime = `${sourceEvent.datum} 20:15`;
tempusApi
.updateKalenderEvent(
sourceEvent.kalender_id,
startDateTime,
endDateTime,
)
.then((response) => {
expect(response.status).to.eq(500);
expect(response.body).to.have.nested.property(
"meta.status",
"error",
);
expect(response.body.errors).to.be.an("array");
let hasReservationCollisionError = response.body.errors.some(
(error) => error.errorCode === "lector_collision",
);
expect(
hasReservationCollisionError,
"response contains lector collision error",
).to.be.true;
});
});
});
it("checks permission agains the single permission", () => {
rolesinrolesApi.permissionToUser();
});
});
tests/cypress/cypress/support/api/rolesinrolesApi.js
+26 -6
View File
@@ -1,18 +1,38 @@
const DummyPermissionsAPI = "/index.ci.php/system/DummyPermissions";
const DummyPermissionsAPI = "/index.ci.php/system/DummyPermissions/";
export const rolesinrolesApi = {
mainRoleR: function() {
permissionToMainRole: () => {
cy
.request({
method: 'GET',
url: DummyPermissionsAPI,
url: DummyPermissionsAPI + "permissionToMainRole",
})
.then((response) => {
expect(response.status).to.eq(200);
expect(response.body).to.have.nested.property("meta.status", "success");
expect(response.body.data).to.be.an("array");
expect(response.body).to.equals("DummyPermissions::permissionToMainRole");
})
},
permissionToBasicRole: () => {
return response.body.data;
cy
.request({
method: 'GET',
url: DummyPermissionsAPI + "permissionToBasicRole",
})
.then((response) => {
expect(response.status).to.eq(200);
expect(response.body).to.equals("DummyPermissions::permissionToBasicRole");
})
},
permissionToUser: () => {
cy
.request({
method: 'GET',
url: DummyPermissionsAPI + "permissionToUser",
})
.then((response) => {
expect(response.status).to.eq(200);
expect(response.body).to.equals("DummyPermissions::permissionToUser");
})
},
};
tests/cypress/cypress/support/commands.js
+62
View File
@@ -0,0 +1,62 @@
// ***********************************************
// This example commands.js shows you how to
// create various custom commands and overwrite
// existing commands.
//
// For more comprehensive examples of custom
// commands please read more here:
// https://on.cypress.io/custom-commands
// ***********************************************
//
//
// -- This is a parent command --
// Cypress.Commands.add('login', (email, password) => { ... })
//
//
// -- This is a child command --
// Cypress.Commands.add('drag', { prevSubject: 'element'}, (subject, options) => { ... })
//
//
// -- This is a dual command --
// Cypress.Commands.add('dismiss', { prevSubject: 'optional'}, (subject, options) => { ... })
//
//
// -- This will overwrite an existing command --
// Cypress.Commands.overwrite('visit', (originalFn, url, options) => { ... })
require("@4tw/cypress-drag-drop");
require("cypress-real-events")
Cypress.Commands.add("login", () => {
const { adminusername, adminpassword, loginAsUser } = Cypress.env();
const userToImpersonate = loginAsUser || adminusername;
const auth = {
username: adminusername,
password: adminpassword,
};
cy.session(
["ci-login", adminusername, userToImpersonate],
() => {
cy.request({
url: "/index.ci.php",
method: "GET",
auth,
body: {
searchstr: userToImpersonate,
types: ["employee"],
},
}).its("status").should("eq", 200);
},
{
cacheAcrossSpecs: true,
validate() {
cy.request({
url: "/index.ci.php",
auth,
}).its("status").should("eq", 200);
},
},
);
});
tests/cypress/cypress/support/helpers/date.js
-21
View File
@@ -1,21 +0,0 @@
import moment from "moment";
export function getDateForDay(dayName) {
const days = {
monday: 0,
tuesday: 1,
wednesday: 2,
thursday: 3,
friday: 4,
saturday: 5,
sunday: 6,
};
const dayIndex = days[dayName.toLowerCase()];
if (dayIndex === undefined) {
throw new Error(`Invalid day name: ${dayName}`);
}
return moment().startOf("isoWeek").add(dayIndex, "days").format("YYYY-MM-DD");
}
tests/cypress/cypress/support/helpers/network.js
-2
View File
@@ -1,2 +0,0 @@
export const waitForOk = (alias) =>
cy.wait(alias).its("response.statusCode").should("eq", 200);