fix: solve coverage issues

Author: bra-i-am

src/authz/hooks.test.ts

@@ -0,0 +1,78 @@
+import { renderHook } from '@testing-library/react';
+import { useUserPermissions } from '@src/authz/data/apiHooks';
+import { mockWaffleFlags } from '@src/data/apiHooks.mock';
+import { useUserPermissionsWithAuthzCourse } from './hooks';
+import { COURSE_PERMISSIONS } from './constants';
+
+jest.mock('@src/authz/data/apiHooks', () => ({
+  useUserPermissions: jest.fn(),
+}));
+
+const courseId = 'course-v1:org+course+run';
+const permissions = {
+  canView: { action: COURSE_PERMISSIONS.VIEW_GRADING_SETTINGS, scope: courseId },
+  canEdit: { action: COURSE_PERMISSIONS.EDIT_GRADING_SETTINGS, scope: courseId },
+};
+
+describe('useUserPermissionsWithAuthzCourse', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.mocked(useUserPermissions).mockReturnValue({
+      isLoading: false,
+      data: undefined,
+    } as unknown as ReturnType<typeof useUserPermissions>);
+  });
+
+  it('defaults all permissions to true when authz is disabled', () => {
+    mockWaffleFlags({ enableAuthzCourseAuthoring: false });
+
+    const { result } = renderHook(() => useUserPermissionsWithAuthzCourse(courseId, permissions));
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.isAuthzEnabled).toBe(false);
+    expect(result.current.permissions.canView).toBe(true);
+    expect(result.current.permissions.canEdit).toBe(true);
+  });
+
+  it('returns actual permission values when authz is enabled and permissions are loaded', () => {
+    mockWaffleFlags({ enableAuthzCourseAuthoring: true });
+    jest.mocked(useUserPermissions).mockReturnValue({
+      isLoading: false,
+      data: { canView: true, canEdit: false },
+    } as unknown as ReturnType<typeof useUserPermissions>);
+
+    const { result } = renderHook(() => useUserPermissionsWithAuthzCourse(courseId, permissions));
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.isAuthzEnabled).toBe(true);
+    expect(result.current.permissions.canView).toBe(true);
+    expect(result.current.permissions.canEdit).toBe(false);
+  });
+
+  it('returns isLoading=true and empty permissions while authz permissions are loading', () => {
+    mockWaffleFlags({ enableAuthzCourseAuthoring: true });
+    jest.mocked(useUserPermissions).mockReturnValue({
+      isLoading: true,
+      data: undefined,
+    } as unknown as ReturnType<typeof useUserPermissions>);
+
+    const { result } = renderHook(() => useUserPermissionsWithAuthzCourse(courseId, permissions));
+
+    expect(result.current.isLoading).toBe(true);
+    expect(result.current.isAuthzEnabled).toBe(true);
+    expect(result.current.permissions).toEqual({});
+  });
+
+  it('falls back to false for permissions absent from server response when authz is enabled', () => {
+    mockWaffleFlags({ enableAuthzCourseAuthoring: true });
+    jest.mocked(useUserPermissions).mockReturnValue({
+      isLoading: false,
+      data: {},
+    } as unknown as ReturnType<typeof useUserPermissions>);
+
+    const { result } = renderHook(() => useUserPermissionsWithAuthzCourse(courseId, permissions));
+
+    expect(result.current.permissions.canView).toBe(false);
+    expect(result.current.permissions.canEdit).toBe(false);
+  });
+});

src/grading-settings/assignment-section/AssignmentSection.test.jsx

@@ -3,6 +3,8 @@ import { render, waitFor, fireEvent } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
 import AssignmentSection from '.';
+import AssignmentItem from './assignments/AssignmentItem';
+import AssignmentTypeName from './assignments/AssignmentTypeName';
 import messages from './messages';
 
 const testObj = {};
@@ -108,6 +110,45 @@ describe('<AssignmentSection />', () => {
       expect(getByText(messages.totalNumberErrorMessage.defaultMessage)).toBeInTheDocument();
     });
   });
+  it('should disable all inputs and delete button when isEditable is false', async () => {
+    const { getAllByRole, getByText } = render(<RootWrapper isEditable={false} />);
+    await waitFor(() => {
+      const inputs = getAllByRole('textbox').concat(getAllByRole('spinbutton'));
+      inputs.forEach((input) => expect(input).toBeDisabled());
+      const deleteBtn = getByText(messages.assignmentDeleteButton.defaultMessage).closest('button');
+      expect(deleteBtn).toBeDisabled();
+    });
+  });
+
+  it('renders AssignmentItem with default disabled=false when prop is omitted', () => {
+    const { getByTestId } = render(
+      <IntlProvider locale="en">
+        <ul>
+          <AssignmentItem
+            title="Test"
+            descriptions="Test description"
+            type="text"
+            name="shortLabel"
+            className="test-class"
+            onChange={jest.fn()}
+          />
+        </ul>
+      </IntlProvider>,
+    );
+    expect(getByTestId('assignment-shortLabel-input')).not.toBeDisabled();
+  });
+
+  it('renders AssignmentTypeName with default disabled=false when prop is omitted', () => {
+    const { getByTestId } = render(
+      <IntlProvider locale="en">
+        <ul>
+          <AssignmentTypeName value="Homework" onChange={jest.fn()} />
+        </ul>
+      </IntlProvider>,
+    );
+    expect(getByTestId('assignment-type-name-input')).not.toBeDisabled();
+  });
+
   it('checking correct error msg if total weight have negative number', async () => {
     const { getByText, getByTestId } = render(<RootWrapper />);
     await waitFor(() => {

src/grading-settings/grading-scale/GradingScale.test.jsx

@@ -4,6 +4,8 @@ import { initializeMockApp } from '@edx/frontend-platform';
 import { render, waitFor, fireEvent } from '@testing-library/react';
 
 import GradingScale from './GradingScale';
+import GradingScaleHandle from './components/GradingScaleHandle';
+import GradingScaleSegment from './components/GradingScaleSegment.tsx';
 
 const gradeCutoffs = { A: 0.9, B: 0.8, C: 0.7 };
 
@@ -122,6 +124,73 @@ describe('<GradingScale />', () => {
     });
   });
 
+  it('renders GradingScaleHandle with default isEditable=true when prop is omitted', () => {
+    const gradingSegments = [
+      { current: 90, previous: 0 },
+      { current: 100, previous: 90 },
+    ];
+    const { container } = render(
+      <GradingScaleHandle
+        idx={0}
+        value={90}
+        gradingSegments={gradingSegments}
+        getHandleProps={() => ({})}
+      />,
+    );
+    const btn = container.querySelector('.grading-scale-segment-btn-resize');
+    expect(btn).toBeInTheDocument();
+    expect(btn).not.toBeDisabled();
+  });
+
+  it('renders GradingScaleSegment with default isEditable=true when prop is omitted', async () => {
+    const gradingSegments = [
+      { current: 100, previous: 0 },
+      { current: 50, previous: 0 },
+      { current: 30, previous: 0 },
+    ];
+    const { getAllByTestId } = render(
+      <IntlProvider locale="en" messages={{}}>
+        <GradingScaleSegment
+          idx={1}
+          value={50}
+          getSegmentProps={() => ({})}
+          handleLetterChange={jest.fn()}
+          letters={['A', 'B', 'C']}
+          gradingSegments={gradingSegments}
+          removeGradingSegment={jest.fn()}
+        />
+      </IntlProvider>,
+    );
+    await waitFor(() => {
+      getAllByTestId('grading-scale-segment-input').forEach((input) => expect(input).not.toBeDisabled());
+    });
+  });
+
+  it('should disable inputs and buttons when isEditable is false', async () => {
+    const { getAllByTestId, queryAllByTestId } = render(
+      <IntlProvider locale="en" messages={{}}>
+        <GradingScale
+          gradeCutoffs={gradeCutoffs}
+          gradeLetters={gradeLetters}
+          sortedGrades={sortedGrades}
+          resetDataRef={{ current: false }}
+          showSavePrompt={jest.fn()}
+          setShowSuccessAlert={jest.fn()}
+          setGradingData={jest.fn()}
+          setOverrideInternetConnectionAlert={jest.fn()}
+          setEligibleGrade={jest.fn()}
+          isEditable={false}
+        />
+      </IntlProvider>,
+    );
+    await waitFor(() => {
+      const segmentInputs = getAllByTestId('grading-scale-segment-input');
+      segmentInputs.forEach((input) => expect(input).toBeDisabled());
+      const removeButtons = queryAllByTestId('grading-scale-btn-remove');
+      removeButtons.forEach((btn) => expect(btn).toBeDisabled());
+    });
+  });
+
   it('should render GradingScale component with more than 5 grades', async () => {
     const { getAllByTestId } = render(
       <IntlProvider locale="en" messages={{}}>