WIP: deleting from db--update store tests

WIP: cleanup the tests


WIP: deleting from db--update store tests

Author: pstaabp

lib/DB/Schema/ResultSet/ProblemPool.pm

@@ -333,6 +333,7 @@ sub getPoolProblem ($self, %args) {
 				. ' is not in the pool named \''
 				. $problem_pool->pool_name
 				. "'");
+		return;
 	} else {
 		# Pick a random problem.
 		my $prob = $pool_problems[ rand @pool_problems ];

lib/WeBWorK3.pm

@@ -172,6 +172,7 @@ sub problemSetRoutes ($app, $course_routes) {
 	# CRUD for User Sets
 	$course_routes->get('/user-sets')->to('ProblemSet#getAllUserSets');
 	$course_routes->get('/sets/:set_id/users')->to('ProblemSet#getUserSets');
+	$course_routes->get('/sets/:set_id/users/:course_user_id')->to('ProblemSet#getUserSet');
 	$course_routes->post('/sets/:set_id/users')->to('ProblemSet#addUserSet');
 	$course_routes->put('/sets/:set_id/users/:course_user_id')->to('ProblemSet#updateUserSet');
 	$course_routes->delete('/sets/:set_id/users/:course_user_id')->to('ProblemSet#deleteUserSet');

lib/WeBWorK3/Controller/ProblemSet.pm

@@ -106,6 +106,18 @@ sub getUserSets ($self) {
 	return;
 }
 
+sub getUserSet ($self) {
+	my $user_set = $self->schema->resultset('UserSet')->getUserSet(
+		info => {
+			course_id      => int($self->param('course_id')),
+			set_id         => int($self->param('set_id')),
+			course_user_id => int($self->param('course_user_id'))
+		}
+	);
+	$self->render(json => $user_set);
+	return;
+}
+
 sub addUserSet ($self) {
 	my $new_user_set = $self->schema->resultset('UserSet')->addUserSet(
 		params => {

src/stores/courses.ts

@@ -77,13 +77,11 @@ export const useCourseStore = defineStore('courses', {
 		/**
 		 * This deletes the course in the database and the store.
 		 */
-		async deleteCourse(course: Course): Promise<Course | undefined> {
+		async deleteCourse(course: Course): Promise<void> {
 			const response = await api.delete(`courses/${course.course_id}`);
 			if (response.status === 200) {
-				const deleted_course = new Course(response.data as ParseableCourse);
-				const index = this.courses.findIndex(course => course.course_id === deleted_course.course_id);
+				const index = this.courses.findIndex(c => c.course_id === course.course_id);
 				this.courses.splice(index, 1);
-				return deleted_course;
 			} else {
 				throw response.data as ResponseError;
 			}

src/stores/problem_sets.ts

@@ -180,15 +180,19 @@ export const useProblemSetStore = defineStore('problem_sets', {
 		/**
 		 * Delete the given ProblemSet from the database and the store.
 		 */
-		async deleteProblemSet(set: ProblemSet) {
+		async deleteProblemSet(set: ProblemSet): Promise<void> {
 			const response = await api.delete(`courses/${set.course_id}/sets/${set.set_id}`);
-			const set_to_delete = parseProblemSet(response.data as ParseableProblemSet);
-			const index = this.problem_sets.findIndex(set => set.set_id === set_to_delete.set_id);
-			if (index >= 0) {
-				this.problem_sets.splice(index, 1);
+			if (response.status === 200) {
+				const index = this.problem_sets.findIndex((s) => s.set_id === set.set_id);
+				if (index < 0) {
+					logger.error('[problem_set store/deleteProblemSet]: the problem set was not found in the store');
+				} else {
+					// splice is used so vue3 reacts to changes.
+					this.problem_sets.splice(index, 1);
+				}
+			} else {
+				logger.error(JSON.stringify(response));
 			}
-			// TODO: what if this fails
-			return set_to_delete;
 		},
 		// UserSet actions
 
@@ -268,16 +272,21 @@ export const useProblemSetStore = defineStore('problem_sets', {
 		/**
 		 * Deletes the given UserSet from the store and the database.
 		 */
-		async deleteUserSet(user_set: UserSet) {
+		async deleteUserSet(user_set: UserSet): Promise<void> {
 			const course_id = useSessionStore().course.course_id;
 			const response = await
 			api.delete(`courses/${course_id}/sets/${user_set.set_id}/users/${user_set.course_user_id ?? 0}`);
-			// TODO: check for errors
-			const deleted_user_set = parseDBUserSet(response.data as ParseableDBUserSet);
-			const index = this.db_user_sets.findIndex(s => s.user_set_id === deleted_user_set.user_set_id);
-			this.db_user_sets.splice(index, 1);
-			user_set.set(deleted_user_set.toObject());
-			return user_set;
+			if (response.status === 200) {
+				const index = this.db_user_sets.findIndex((set) => set.user_set_id === user_set.user_set_id);
+				if (index < 0) {
+					logger.error('[user store/deleteUserSet]: the user set was not found in the store');
+				} else {
+					// splice is used so vue3 reacts to changes.
+					this.db_user_sets.splice(index, 1);
+				}
+			} else {
+				logger.error(JSON.stringify(response));
+			}
 		},
 
 		/**

src/stores/set_problems.ts

@@ -157,16 +157,18 @@ export const useSetProblemStore = defineStore('set_problems', {
 		/**
 		 * Delete the given SetProblem in both the store and the database.
 		 */
-		async deleteSetProblem(problem: SetProblem): Promise<SetProblem> {
+		async deleteSetProblem(problem: SetProblem): Promise<void> {
 			const course_id = useSessionStore().course.course_id;
 
-			const response = await api.delete(`courses/${course_id}/sets/${
+			await api.delete(`courses/${course_id}/sets/${
 				problem.set_id}/problems/${problem.set_problem_id}`);
-			const deleted_problem = new SetProblem(response.data as ParseableSetProblem);
-			// TODO: check for errors
-			const index = this.set_problems.findIndex(prob => prob.set_problem_id === deleted_problem.set_problem_id);
-			this.set_problems.splice(index, 1);
-			return deleted_problem;
+			const index = this.set_problems.findIndex(prob => prob.set_problem_id === problem.set_problem_id);
+			if (index < 0) {
+				logger.error('[stores/set_problems/deleteSetProblem]: the set problem was not found in the store');
+			} else {
+				// splice is used so vue3 reacts to changes.
+				this.set_problems.splice(index, 1);
+			}
 		},
 		// UserProblem actions
 
@@ -241,26 +243,25 @@ export const useSetProblemStore = defineStore('set_problems', {
 		/**
 		 * Delete the given UserProblem from the database and the store.
 		 */
-		async deleteUserProblem(user_problem: UserProblem): Promise<UserProblem> {
+		async deleteUserProblem(user_problem: UserProblem): Promise<void> {
 			const course_id = useSessionStore().course.course_id;
 			const set_problem = this.set_problems.find(prob => prob.set_problem_id === user_problem.set_problem_id);
 			const problem_set_store = useProblemSetStore();
 			const user_set = problem_set_store.findUserSet({ user_set_id: user_problem.user_set_id,  });
 			if (user_set == undefined) {
 				throw 'deleteUserProblem: returned undefined user set';
 			}
-			const response = await api.delete(`courses/${course_id}/sets/${set_problem?.set_id ?? 0
+			await api.delete(`courses/${course_id}/sets/${set_problem?.set_id ?? 0
 			}/users/${user_set.user_id}/problems/${user_problem.user_problem_id}`);
-			const db_deleted_problem = new DBUserProblem(response.data as ParseableDBUserProblem);
+
 			const index = this.db_user_problems
-				.findIndex(user_problem => user_problem.user_problem_id === db_deleted_problem.user_problem_id);
-			if (index >= 0) {
-				this.db_user_problems.splice(index, 1);
+				.findIndex(user_problem => user_problem.user_problem_id === user_problem.user_problem_id);
+			if (index < 0) {
+				logger.error('[stores/set_problems/deleteUserProblem]: the set problem was not found in the store');
+			} else {
+				// splice is used so vue3 reacts to changes.
+				this.set_problems.splice(index, 1);
 			}
-			// Create a new UserProblem to return as
-			const deleted_user_problem = new UserProblem(Object.assign(db_deleted_problem.toObject(),
-				user_problem.toObject()));
-			return deleted_user_problem;
 		}
 	}
 });

src/stores/users.ts

@@ -2,7 +2,7 @@ import { api } from 'boot/axios';
 import { defineStore } from 'pinia';
 
 import { logger } from 'boot/logger';
-import { DBCourseUser, ParseableCourseUser, ParseableDBCourseUser, ParseableUser } from 'src/common/models/users';
+import { DBCourseUser, ParseableDBCourseUser, ParseableUser } from 'src/common/models/users';
 import { User, CourseUser } from 'src/common/models/users';
 import { invalidError, ResponseError } from 'src/common/api-requests/errors';
 import { UserRole } from 'src/stores/permissions';
@@ -155,15 +155,20 @@ export const useUserStore = defineStore('user', {
 		/**
 		 * Deletes the given User in the database and in the store.
 		 */
-		async deleteUser(user: User): Promise<User | undefined> {
+		async deleteUser(user: User): Promise<void> {
 			const session_store = useSessionStore();
 			const course_id = session_store.course.course_id;
 			const response = await api.delete(`courses/${course_id}/global-users/${user.user_id ?? 0}`);
 			if (response.status === 200) {
 				const index = this.users.findIndex((u) => u.user_id === user.user_id);
-				// splice is used so vue3 reacts to changes.
-				this.users.splice(index, 1);
-				return new User(response.data as ParseableUser);
+				if (index < 0) {
+					logger.error('[user store/deleteUser]: the user was not found in the store');
+				} else {
+					// splice is used so vue3 reacts to changes.
+					this.users.splice(index, 1);
+				}
+			} else {
+				logger.error(JSON.stringify(response));
 			}
 		},
 
@@ -261,16 +266,16 @@ export const useUserStore = defineStore('user', {
 		/**
 		 * Deletes a Course User from the store and the database.
 		 */
-		async deleteCourseUser(course_user: CourseUser): Promise<CourseUser | undefined> {
+		async deleteCourseUser(course_user: CourseUser): Promise<void> {
 			const response = await api.delete(`courses/${course_user.course_id}/users/${course_user.user_id}`);
 			if (response.status === 200) {
 				const index = this.db_course_users.findIndex((u) => u.course_user_id === course_user.course_user_id);
-
-				// splice is used so vue3 reacts to changes.
-				this.db_course_users.splice(index, 1);
-				const deleted_course_user = new DBCourseUser(response.data as ParseableCourseUser);
-				const user = this.users.find(u => u.user_id === deleted_course_user.user_id);
-				return new CourseUser(Object.assign({}, user?.toObject(), deleted_course_user.toObject()));
+				if (index < 0) {
+					logger.error('[user store/deleteCourseUser]: the user was not found in the store');
+				} else {
+					// splice is used so vue3 reacts to changes.
+					this.db_course_users.splice(index, 1);
+				}
 			} else if (response.status === 250) {
 				logger.error(response.data);
 				throw response.data as ResponseError;

t/db/007_user_set.t

@@ -132,7 +132,7 @@ for my $user_set (@merged_user_sets) {
 	$user_set->{set_visible} = $set->{set_visible} unless defined($user_set->{set_visible});
 }
 
-# Get all user sets for a given user in a course.
+# Get all user sets
 my @all_user_sets_from_db = $user_set_rs->getAllUserSets();
 
 for my $set (@all_user_sets_from_db) {

t/mojolicious/005_problem_sets.t

@@ -147,7 +147,7 @@ my $another_new_set = { name => 'this is the wrong field' };
 $t->post_ok('/webwork3/api/courses/4/sets' => json => $another_new_set)
 	->content_type_is('application/json;charset=UTF-8')->json_is('/exception' => 'DB::Exception::ParametersNeeded');
 
-# Some cleanup to restore the databse
+# Some cleanup to restore the database
 # Delete an existing set.
 $t->delete_ok("/webwork3/api/courses/4/sets/$new_set_id")->content_type_is('application/json;charset=UTF-8')
 	->status_is(200);

tests/stores/courses.spec.ts

@@ -16,6 +16,7 @@ import { api } from 'boot/axios';
 import { useCourseStore } from 'src/stores/courses';
 import { Course } from 'src/common/models/courses';
 import { cleanIDs, loadCSV } from '../utils';
+import { AxiosError } from 'axios';
 
 describe('Test the course store', () => {
 
@@ -78,8 +79,18 @@ describe('Test the course store', () => {
 
 		test('Delete a course', async () => {
 			const course_store = useCourseStore();
-			const deleted_course = await course_store.deleteCourse(added_course) ?? new Course();
-			expect(cleanIDs(deleted_course)).toStrictEqual(cleanIDs(updated_course));
+			await course_store.deleteCourse(added_course);
+
+			// Check that the course is no longer in the database by getting an exception.
+			await api.get(`/courses/${added_course.course_id}`)
+				.then(() => {
+					fail('Expected failure response');
+				})
+				.catch((e: AxiosError) => {
+					expect(e.response?.status).toBe(500);
+					expect((e.response?.data as {exception: string}).exception)
+						.toBe('DB::Exception::CourseNotFound');
+				});
 		});
 	});
 
@@ -92,8 +103,9 @@ describe('Test the course store', () => {
 				course_name: ''
 			});
 			expect(course.isValid()).toBe(false);
-			await expect(async () => { await course_store.addCourse(course); })
-				.rejects.toThrow('The added course is invalid');
+			await expect(async () => {
+				await course_store.addCourse(course);
+			}).rejects.toThrow('The added course is invalid');
 		});
 
 		test('Try to update an invalid course', async () => {