From 6c472be6947757c59ee2fe32a549b685c8af4318 Mon Sep 17 00:00:00 2001
From: vladislavkeblysh <vladislav.keblysh@raccoongang.com>
Date: Tue, 24 Oct 2023 21:51:07 +0300
Subject: [PATCH] feat: fixed assignment and course grade fields validations

---
 .../__snapshots__/index.test.jsx.snap         |  2 +-
 .../AssignmentGradeFilter/hooks.js            |  2 +
 .../AssignmentGradeFilter/hooks.test.js       | 10 ++-
 .../AssignmentGradeFilter/index.jsx           |  3 +-
 .../AssignmentGradeFilter/index.test.jsx      |  1 +
 .../__snapshots__/index.test.jsx.snap         |  7 ++
 .../GradesView/StatusAlerts/hooks.js          | 30 +++++--
 .../GradesView/StatusAlerts/hooks.test.js     | 78 ++++++++++++++++---
 .../GradesView/StatusAlerts/index.jsx         | 14 +++-
 .../GradesView/StatusAlerts/index.test.jsx    | 14 +++-
 .../GradesView/StatusAlerts/messages.js       | 20 +++++
 src/data/redux/hooks/selectors.js             |  2 +
 src/data/redux/hooks/selectors.test.js        |  1 +
 src/data/selectors/app.js                     | 35 ++++++++-
 src/data/selectors/app.test.js                | 61 ++++++++++++---
 15 files changed, 241 insertions(+), 39 deletions(-)

diff --git a/src/components/GradebookFilters/AssignmentGradeFilter/__snapshots__/index.test.jsx.snap b/src/components/GradebookFilters/AssignmentGradeFilter/__snapshots__/index.test.jsx.snap
index 109d1d7d..39d51b68 100644
--- a/src/components/GradebookFilters/AssignmentGradeFilter/__snapshots__/index.test.jsx.snap
+++ b/src/components/GradebookFilters/AssignmentGradeFilter/__snapshots__/index.test.jsx.snap
@@ -55,7 +55,7 @@ exports[`AssignmentFilter component render without selected assignment snapshot
     className="grade-filter-action"
   >
     <Button
-      disabled={true}
+      disabled={false}
       name="assignmentGradeMinMax"
       type="submit"
       variant="outline-secondary"
diff --git a/src/components/GradebookFilters/AssignmentGradeFilter/hooks.js b/src/components/GradebookFilters/AssignmentGradeFilter/hooks.js
index adaf0a6d..0bd204bc 100644
--- a/src/components/GradebookFilters/AssignmentGradeFilter/hooks.js
+++ b/src/components/GradebookFilters/AssignmentGradeFilter/hooks.js
@@ -7,6 +7,7 @@ const useAssignmentGradeFilterData = ({ updateQueryParams }) => {
   const fetchGrades = thunkActions.grades.useFetchGrades();
   const setFilter = actions.app.useSetLocalFilter();
   const updateAssignmentLimits = actions.filters.useUpdateAssignmentLimits();
+  const isDisabled = !selectors.app.useAreAssignmentGradeFiltersValid() || !selectedAssignment;
 
   const handleSubmit = () => {
     updateAssignmentLimits(localAssignmentLimits);
@@ -27,6 +28,7 @@ const useAssignmentGradeFilterData = ({ updateQueryParams }) => {
     assignmentGradeMin,
     assignmentGradeMax,
     selectedAssignment,
+    isDisabled,
     handleSetMax,
     handleSetMin,
     handleSubmit,
diff --git a/src/components/GradebookFilters/AssignmentGradeFilter/hooks.test.js b/src/components/GradebookFilters/AssignmentGradeFilter/hooks.test.js
index 817f3769..8aa67fb1 100644
--- a/src/components/GradebookFilters/AssignmentGradeFilter/hooks.test.js
+++ b/src/components/GradebookFilters/AssignmentGradeFilter/hooks.test.js
@@ -4,7 +4,10 @@ import useAssignmentGradeFilterData from './hooks';
 
 jest.mock('data/redux/hooks', () => ({
   selectors: {
-    app: { useAssignmentGradeLimits: jest.fn() },
+    app: {
+      useAreAssignmentGradeFiltersValid: jest.fn(),
+      useAssignmentGradeLimits: jest.fn(),
+    },
     filters: { useSelectedAssignmentLabel: jest.fn() },
   },
   actions: {
@@ -20,6 +23,7 @@ let out;
 
 const assignmentGradeLimits = { assignmentGradeMax: 200, assignmentGradeMin: 3 };
 const selectedAssignmentLabel = 'test-assignment-label';
+const useAreAssignmentGradeFiltersValid = false;
 selectors.app.useAssignmentGradeLimits.mockReturnValue(assignmentGradeLimits);
 selectors.filters.useSelectedAssignmentLabel.mockReturnValue(selectedAssignmentLabel);
 
@@ -40,6 +44,7 @@ describe('useAssignmentFilterData hook', () => {
   });
   describe('behavior', () => {
     it('initializes redux hooks', () => {
+      expect(selectors.app.useAreAssignmentGradeFiltersValid).toHaveBeenCalledWith();
       expect(selectors.app.useAssignmentGradeLimits).toHaveBeenCalledWith();
       expect(selectors.filters.useSelectedAssignmentLabel).toHaveBeenCalledWith();
       expect(actions.app.useSetLocalFilter).toHaveBeenCalledWith();
@@ -77,5 +82,8 @@ describe('useAssignmentFilterData hook', () => {
       expect(out.assignmentGradeMax).toEqual(assignmentGradeLimits.assignmentGradeMax);
       expect(out.assignmentGradeMin).toEqual(assignmentGradeLimits.assignmentGradeMin);
     });
+    it('passes isDisabled from hook', () => {
+      expect(out.isDisabled).toEqual(!useAreAssignmentGradeFiltersValid || !selectedAssignmentLabel);
+    });
   });
 });
diff --git a/src/components/GradebookFilters/AssignmentGradeFilter/index.jsx b/src/components/GradebookFilters/AssignmentGradeFilter/index.jsx
index 5f96a8d6..440ed34f 100644
--- a/src/components/GradebookFilters/AssignmentGradeFilter/index.jsx
+++ b/src/components/GradebookFilters/AssignmentGradeFilter/index.jsx
@@ -13,6 +13,7 @@ export const AssignmentGradeFilter = ({ updateQueryParams }) => {
     assignmentGradeMin,
     assignmentGradeMax,
     selectedAssignment,
+    isDisabled,
     handleSetMax,
     handleSetMin,
     handleSubmit,
@@ -39,7 +40,7 @@ export const AssignmentGradeFilter = ({ updateQueryParams }) => {
           type="submit"
           variant="outline-secondary"
           name="assignmentGradeMinMax"
-          disabled={!selectedAssignment}
+          disabled={isDisabled}
           onClick={handleSubmit}
         >
           {formatMessage(messages.apply)}
diff --git a/src/components/GradebookFilters/AssignmentGradeFilter/index.test.jsx b/src/components/GradebookFilters/AssignmentGradeFilter/index.test.jsx
index 18c59199..82f52a49 100644
--- a/src/components/GradebookFilters/AssignmentGradeFilter/index.test.jsx
+++ b/src/components/GradebookFilters/AssignmentGradeFilter/index.test.jsx
@@ -17,6 +17,7 @@ const hookData = {
   selectedAssignment: 'test-assignment',
   assignmentGradeMax: 300,
   assignmentGradeMin: 23,
+  isDisabled: false,
 };
 useAssignmentGradeFilterData.mockReturnValue(hookData);
 
diff --git a/src/components/GradesView/StatusAlerts/__snapshots__/index.test.jsx.snap b/src/components/GradesView/StatusAlerts/__snapshots__/index.test.jsx.snap
index a842973d..de44c295 100644
--- a/src/components/GradesView/StatusAlerts/__snapshots__/index.test.jsx.snap
+++ b/src/components/GradesView/StatusAlerts/__snapshots__/index.test.jsx.snap
@@ -16,5 +16,12 @@ exports[`StatusAlerts component render snapshot 1`] = `
   >
     hooks.grade-filter-text
   </Alert>
+  <Alert
+    dismissible={false}
+    show="hooks.show-grade-filter"
+    variant="danger"
+  >
+    hooks.grade-filter-text
+  </Alert>
 </Fragment>
 `;
diff --git a/src/components/GradesView/StatusAlerts/hooks.js b/src/components/GradesView/StatusAlerts/hooks.js
index efcd8a56..1925328b 100644
--- a/src/components/GradesView/StatusAlerts/hooks.js
+++ b/src/components/GradesView/StatusAlerts/hooks.js
@@ -6,15 +6,27 @@ import messages from './messages';
 export const useStatusAlertsData = () => {
   const { formatMessage } = useIntl();
 
-  const limitValidity = selectors.app.useCourseGradeFilterValidity();
+  const courseLimitValidity = selectors.app.useCourseGradeFilterValidity();
+  const assignmentLimitValidity = selectors.app.useAssignmentGradeFilterValidity();
+
   const showSuccessBanner = selectors.grades.useShowSuccess();
   const handleCloseSuccessBanner = actions.grades.useCloseBanner();
 
-  const isCourseGradeFilterAlertOpen = !limitValidity.isMinValid || !limitValidity.isMaxValid;
+  const isCourseGradeFilterAlertOpen = !courseLimitValidity.isMinValid
+    || !courseLimitValidity.isMaxValid || !courseLimitValidity.isMinLessMaxValid;
+  const isAssignmentGradeFilterAlertOpen = !assignmentLimitValidity.isMinValid
+    || !assignmentLimitValidity.isMaxValid || !assignmentLimitValidity.isMinLessMaxValid;
+
+  const courseValidityMessages = {
+    min: courseLimitValidity.isMinValid ? '' : formatMessage(messages.minGradeInvalid),
+    max: courseLimitValidity.isMaxValid ? '' : formatMessage(messages.maxGradeInvalid),
+    minLessMax: courseLimitValidity.isMinLessMaxValid ? '' : formatMessage(messages.minLessMaxGradeInvalid),
+  };
 
-  const validityMessages = {
-    min: limitValidity.isMinValid ? '' : formatMessage(messages.minGradeInvalid),
-    max: limitValidity.isMaxValid ? '' : formatMessage(messages.maxGradeInvalid),
+  const assignmentValidityMessages = {
+    min: assignmentLimitValidity.isMinValid ? '' : formatMessage(messages.minAssignmentInvalid),
+    max: assignmentLimitValidity.isMaxValid ? '' : formatMessage(messages.maxAssignmentInvalid),
+    minLessMax: assignmentLimitValidity.isMinLessMaxValid ? '' : formatMessage(messages.minLessMaxAssignmentInvalid),
   };
 
   return {
@@ -23,9 +35,13 @@ export const useStatusAlertsData = () => {
       show: showSuccessBanner,
       text: formatMessage(messages.editSuccessAlert),
     },
-    gradeFilter: {
+    courseGradeFilter: {
       show: isCourseGradeFilterAlertOpen,
-      text: `${validityMessages.min}${validityMessages.max}`,
+      text: `${courseValidityMessages.min} ${courseValidityMessages.max} ${courseValidityMessages.minLessMax}`,
+    },
+    assignmentGradeFilter: {
+      show: isAssignmentGradeFilterAlertOpen,
+      text: `${assignmentValidityMessages.min} ${assignmentValidityMessages.max} ${assignmentValidityMessages.minLessMax}`,
     },
   };
 };
diff --git a/src/components/GradesView/StatusAlerts/hooks.test.js b/src/components/GradesView/StatusAlerts/hooks.test.js
index 4b0e11f6..8259f11d 100644
--- a/src/components/GradesView/StatusAlerts/hooks.test.js
+++ b/src/components/GradesView/StatusAlerts/hooks.test.js
@@ -11,7 +11,10 @@ jest.mock('data/redux/hooks', () => ({
     grades: { useCloseBanner: jest.fn() },
   },
   selectors: {
-    app: { useCourseGradeFilterValidity: jest.fn() },
+    app: {
+      useCourseGradeFilterValidity: jest.fn(),
+      useAssignmentGradeFilterValidity: jest.fn(),
+    },
     grades: { useShowSuccess: jest.fn() },
   },
 }));
@@ -19,8 +22,10 @@ jest.mock('data/redux/hooks', () => ({
 const validity = {
   isMinValid: true,
   isMaxValid: true,
+  isMinLessMaxValid: true,
 };
 selectors.app.useCourseGradeFilterValidity.mockReturnValue(validity);
+selectors.app.useAssignmentGradeFilterValidity.mockReturnValue(validity);
 const showSuccess = 'test-show-success';
 selectors.grades.useShowSuccess.mockReturnValue(showSuccess);
 const closeBanner = jest.fn().mockName('hooks.closeBanner');
@@ -39,6 +44,7 @@ describe('useStatusAlertsData', () => {
     it('initializes redux hooks', () => {
       expect(actions.grades.useCloseBanner).toHaveBeenCalled();
       expect(selectors.app.useCourseGradeFilterValidity).toHaveBeenCalled();
+      expect(selectors.app.useAssignmentGradeFilterValidity).toHaveBeenCalled();
       expect(selectors.grades.useShowSuccess).toHaveBeenCalled();
     });
   });
@@ -53,9 +59,10 @@ describe('useStatusAlertsData', () => {
       });
     });
     describe('gradeFilter', () => {
-      describe('both filters are valid', () => {
+      describe('all filters are valid', () => {
         test('do not show', () => {
-          expect(out.gradeFilter.show).toEqual(false);
+          expect(out.courseGradeFilter.show).toEqual(false);
+          expect(out.assignmentGradeFilter.show).toEqual(false);
         });
       });
       describe('min filter is invalid', () => {
@@ -63,14 +70,22 @@ describe('useStatusAlertsData', () => {
           selectors.app.useCourseGradeFilterValidity.mockReturnValue({
             isMinValid: false,
             isMaxValid: true,
+            isMinLessMaxValid: true,
+          });
+          selectors.app.useAssignmentGradeFilterValidity.mockReturnValue({
+            isMinValid: false,
+            isMaxValid: true,
+            isMinLessMaxValid: true,
           });
           out = useStatusAlertsData();
         });
         test('show grade filter banner', () => {
-          expect(out.gradeFilter.show).toEqual(true);
+          expect(out.courseGradeFilter.show).toEqual(true);
+          expect(out.assignmentGradeFilter.show).toEqual(true);
         });
         test('filter message', () => {
-          expect(out.gradeFilter.text).toEqual(formatMessage(messages.minGradeInvalid));
+          expect(out.courseGradeFilter.text).toEqual(`${formatMessage(messages.minGradeInvalid)}  `);
+          expect(out.assignmentGradeFilter.text).toEqual(`${formatMessage(messages.minAssignmentInvalid)}  `);
         });
       });
       describe('max filter is invalid', () => {
@@ -78,30 +93,71 @@ describe('useStatusAlertsData', () => {
           selectors.app.useCourseGradeFilterValidity.mockReturnValue({
             isMinValid: true,
             isMaxValid: false,
+            isMinLessMaxValid: true,
+          });
+          selectors.app.useAssignmentGradeFilterValidity.mockReturnValue({
+            isMinValid: true,
+            isMaxValid: false,
+            isMinLessMaxValid: true,
           });
           out = useStatusAlertsData();
         });
         test('show grade filter banner', () => {
-          expect(out.gradeFilter.show).toEqual(true);
+          expect(out.courseGradeFilter.show).toEqual(true);
+          expect(out.assignmentGradeFilter.show).toEqual(true);
         });
         test('filter message', () => {
-          expect(out.gradeFilter.text).toEqual(formatMessage(messages.maxGradeInvalid));
+          expect(out.courseGradeFilter.text).toEqual(` ${formatMessage(messages.maxGradeInvalid)} `);
+          expect(out.assignmentGradeFilter.text).toEqual(` ${formatMessage(messages.maxAssignmentInvalid)} `);
         });
       });
-      describe('both filters are invalid', () => {
+      describe('minLessMax filter is invalid', () => {
         beforeEach(() => {
           selectors.app.useCourseGradeFilterValidity.mockReturnValue({
+            isMinValid: true,
+            isMaxValid: true,
+            isMinLessMaxValid: false,
+          });
+          selectors.app.useAssignmentGradeFilterValidity.mockReturnValue({
+            isMinValid: true,
+            isMaxValid: true,
+            isMinLessMaxValid: false,
+          });
+          out = useStatusAlertsData();
+        });
+        test('show grade filter banner', () => {
+          expect(out.courseGradeFilter.show).toEqual(true);
+          expect(out.assignmentGradeFilter.show).toEqual(true);
+        });
+        test('filter message', () => {
+          expect(out.courseGradeFilter.text).toEqual(`  ${formatMessage(messages.minLessMaxGradeInvalid)}`);
+          expect(out.assignmentGradeFilter.text).toEqual(`  ${formatMessage(messages.minLessMaxAssignmentInvalid)}`);
+        });
+      });
+      describe('all filters are invalid', () => {
+        beforeEach(() => {
+          selectors.app.useCourseGradeFilterValidity.mockReturnValue({
+            isMinValid: false,
+            isMaxValid: false,
+            isMinLessMaxValid: false,
+          });
+          selectors.app.useAssignmentGradeFilterValidity.mockReturnValue({
             isMinValid: false,
             isMaxValid: false,
+            isMinLessMaxValid: false,
           });
           out = useStatusAlertsData();
         });
         test('show grade filter banner', () => {
-          expect(out.gradeFilter.show).toEqual(true);
+          expect(out.courseGradeFilter.show).toEqual(true);
+          expect(out.assignmentGradeFilter.show).toEqual(true);
         });
         test('filter message', () => {
-          expect(out.gradeFilter.text).toEqual(
-            `${formatMessage(messages.minGradeInvalid)}${formatMessage(messages.maxGradeInvalid)}`,
+          expect(out.courseGradeFilter.text).toEqual(
+            `${formatMessage(messages.minGradeInvalid)} ${formatMessage(messages.maxGradeInvalid)} ${formatMessage(messages.minLessMaxGradeInvalid)}`,
+          );
+          expect(out.assignmentGradeFilter.text).toEqual(
+            `${formatMessage(messages.minAssignmentInvalid)} ${formatMessage(messages.maxAssignmentInvalid)} ${formatMessage(messages.minLessMaxAssignmentInvalid)}`,
           );
         });
       });
diff --git a/src/components/GradesView/StatusAlerts/index.jsx b/src/components/GradesView/StatusAlerts/index.jsx
index 020afbd6..4e4aa8f6 100644
--- a/src/components/GradesView/StatusAlerts/index.jsx
+++ b/src/components/GradesView/StatusAlerts/index.jsx
@@ -7,7 +7,8 @@ import useStatusAlertsData from './hooks';
 export const StatusAlerts = () => {
   const {
     successBanner,
-    gradeFilter,
+    courseGradeFilter,
+    assignmentGradeFilter,
   } = useStatusAlertsData();
 
   return (
@@ -22,9 +23,16 @@ export const StatusAlerts = () => {
       <Alert
         variant="danger"
         dismissible={false}
-        show={gradeFilter.show}
+        show={assignmentGradeFilter.show}
       >
-        {gradeFilter.text}
+        {assignmentGradeFilter.text}
+      </Alert>
+      <Alert
+        variant="danger"
+        dismissible={false}
+        show={courseGradeFilter.show}
+      >
+        {courseGradeFilter.text}
       </Alert>
     </>
   );
diff --git a/src/components/GradesView/StatusAlerts/index.test.jsx b/src/components/GradesView/StatusAlerts/index.test.jsx
index 06740d98..1519ac7f 100644
--- a/src/components/GradesView/StatusAlerts/index.test.jsx
+++ b/src/components/GradesView/StatusAlerts/index.test.jsx
@@ -14,7 +14,11 @@ const hookProps = {
     show: 'hooks.show-success-banner',
     text: 'hooks.success-banner-text',
   },
-  gradeFilter: {
+  courseGradeFilter: {
+    show: 'hooks.show-grade-filter',
+    text: 'hooks.grade-filter-text',
+  },
+  assignmentGradeFilter: {
     show: 'hooks.show-grade-filter',
     text: 'hooks.grade-filter-text',
   },
@@ -43,11 +47,13 @@ describe('StatusAlerts component', () => {
       expect(props.show).toEqual(hookProps.successBanner.show);
       expect(alert.children[0].el).toEqual(hookProps.successBanner.text);
     });
-    test('grade filter banner', () => {
+    test('course and assignment filter banner', () => {
       const alert = el.instance.findByType(Alert)[1];
       const { props } = alert;
-      expect(props.show).toEqual(hookProps.gradeFilter.show);
-      expect(alert.children[0].el).toEqual(hookProps.gradeFilter.text);
+      expect(props.show).toEqual(hookProps.courseGradeFilter.show);
+      expect(alert.text()).toEqual(hookProps.courseGradeFilter.text);
+      expect(props.show).toEqual(hookProps.assignmentGradeFilter.show);
+      expect(alert.children[0].el).toEqual(hookProps.assignmentGradeFilter.text);
     });
   });
 });
diff --git a/src/components/GradesView/StatusAlerts/messages.js b/src/components/GradesView/StatusAlerts/messages.js
index 0e6a8da5..8dda228c 100644
--- a/src/components/GradesView/StatusAlerts/messages.js
+++ b/src/components/GradesView/StatusAlerts/messages.js
@@ -16,6 +16,26 @@ const messages = defineMessages({
     defaultMessage: 'Minimum course grade must be between 0 and 100',
     description: 'An alert text for selecting a minimum course grade less than 0',
   },
+  minLessMaxGradeInvalid: {
+    id: 'gradebook.GradesView.minLessMaxGradeInvalid',
+    defaultMessage: 'Minimum course grade must be less than maximum course grade',
+    description: 'An alert text for selecting a minimum course grade must be less than maximum course grade',
+  },
+  maxAssignmentInvalid: {
+    id: 'gradebook.GradesView.maxAssignmentGradeInvalid',
+    defaultMessage: 'Maximum assignment grade must be between 0 and 100',
+    description: 'An alert text for selecting a maximum assignment grade greater than 100',
+  },
+  minAssignmentInvalid: {
+    id: 'gradebook.GradesView.minAssignmentGradeInvalid',
+    defaultMessage: 'Minimum assignment grade must be between 0 and 100',
+    description: 'An alert text for selecting a minimum assignment grade less than 0',
+  },
+  minLessMaxAssignmentInvalid: {
+    id: 'gradebook.GradesView.minLessMaxAssignmentInvalid',
+    defaultMessage: 'Minimum assignment grade must be less than maximum assignment grade',
+    description: 'An alert text for selecting a minimum assignment grade must be less than maximum assignment grade',
+  },
 });
 
 export default messages;
diff --git a/src/data/redux/hooks/selectors.js b/src/data/redux/hooks/selectors.js
index 6f27ab0c..51592cb2 100644
--- a/src/data/redux/hooks/selectors.js
+++ b/src/data/redux/hooks/selectors.js
@@ -23,8 +23,10 @@ export const app = StrictDict({
   useActiveView: selectorHook(selectors.app.activeView),
   useAssignmentGradeLimits: selectorHook(selectors.app.assignmentGradeLimits),
   useAreCourseGradeFiltersValid: selectorHook(selectors.app.areCourseGradeFiltersValid),
+  useAreAssignmentGradeFiltersValid: selectorHook(selectors.app.areAssignmentGradeFiltersValid),
   useCourseGradeLimits: selectorHook(selectors.app.courseGradeLimits),
   useCourseGradeFilterValidity: selectorHook(selectors.app.courseGradeFilterValidity),
+  useAssignmentGradeFilterValidity: selectorHook(selectors.app.assignmentGradeFilterValidity),
   useCourseId: selectorHook(selectors.app.courseId),
   useModalData: selectorHook(selectors.app.modalData),
   useSearchValue: selectorHook(selectors.app.searchValue),
diff --git a/src/data/redux/hooks/selectors.test.js b/src/data/redux/hooks/selectors.test.js
index ad74e30a..24c039c1 100644
--- a/src/data/redux/hooks/selectors.test.js
+++ b/src/data/redux/hooks/selectors.test.js
@@ -59,6 +59,7 @@ describe('selector hooks', () => {
     testHook(hookKeys.useActiveView, selKeys.activeView);
     testHook(hookKeys.useAssignmentGradeLimits, selKeys.assignmentGradeLimits);
     testHook(hookKeys.useAreCourseGradeFiltersValid, selKeys.areCourseGradeFiltersValid);
+    testHook(hookKeys.useAreAssignmentGradeFiltersValid, selKeys.areAssignmentGradeFiltersValid);
     testHook(hookKeys.useCourseGradeLimits, selKeys.courseGradeLimits);
     testHook(hookKeys.useCourseId, selKeys.courseId);
     testHook(hookKeys.useModalData, selKeys.modalData);
diff --git a/src/data/selectors/app.js b/src/data/selectors/app.js
index 4ef2f7c8..e8ce0031 100644
--- a/src/data/selectors/app.js
+++ b/src/data/selectors/app.js
@@ -4,6 +4,25 @@ import simpleSelectorFactory from '../utils';
 import * as module from './app';
 import { minGrade, maxGrade } from './grades';
 
+/**
+ * assignmentGradeFilterValidity(state)
+ * returns { isMaxValid, isMinValid } with each assignment grade limit, verifying they
+ * are between minGrade and maxGrade (0, 100).
+ * @param {object} state - redux state
+ * @return {object} - { isMaxValid, isMinValid, isMinLessMaxValid }
+ */
+export const assignmentGradeFilterValidity = ({ app: { filters } }) => {
+  const isFilterValid = (value) => {
+    const intValue = parseInt(value, 10);
+    return intValue >= minGrade && intValue <= maxGrade;
+  };
+  return {
+    isMaxValid: isFilterValid(filters.assignmentGradeMax),
+    isMinValid: isFilterValid(filters.assignmentGradeMin),
+    isMinLessMaxValid: Number(filters.assignmentGradeMin) <= Number(filters.assignmentGradeMax),
+  };
+};
+
 /**
  * assignmentGradeLimits(state)
  * returns an object of local assignmentGradeMin/Max
@@ -29,6 +48,7 @@ export const courseGradeFilterValidity = ({ app: { filters } }) => {
   return {
     isMaxValid: isFilterValid(filters.courseGradeMax),
     isMinValid: isFilterValid(filters.courseGradeMin),
+    isMinLessMaxValid: Number(filters.courseGradeMin) <= Number(filters.courseGradeMax),
   };
 };
 
@@ -65,7 +85,18 @@ const editUpdateData = ({ app: { modalState } }) => ([{
  */
 const areCourseGradeFiltersValid = (state) => {
   const validity = module.courseGradeFilterValidity(state);
-  return validity.isMinValid && validity.isMaxValid;
+  return validity.isMinValid && validity.isMaxValid && validity.isMinLessMaxValid;
+};
+
+/**
+ * areAssignmentGradeFiltersValid(state)
+ * returns true iff both min and max assignment grade filters are valid (within bounds)
+ * @param {object} state - redux state
+ * @return {bool} - are both filters valid?
+ */
+const areAssignmentGradeFiltersValid = (state) => {
+  const validity = module.assignmentGradeFilterValidity(state);
+  return validity.isMinValid && validity.isMaxValid && validity.isMinLessMaxValid;
 };
 
 const isFilterMenuClosed = ({ app: { filterMenu } }) => (
@@ -117,8 +148,10 @@ const simpleSelectors = simpleSelectorFactory(
 
 export default StrictDict({
   areCourseGradeFiltersValid,
+  areAssignmentGradeFiltersValid,
   assignmentGradeLimits,
   courseGradeFilterValidity,
+  assignmentGradeFilterValidity,
   courseGradeLimits,
   editUpdateData,
   isFilterMenuClosed,
diff --git a/src/data/selectors/app.test.js b/src/data/selectors/app.test.js
index e8d2966d..3da54f57 100644
--- a/src/data/selectors/app.test.js
+++ b/src/data/selectors/app.test.js
@@ -38,21 +38,38 @@ describe('app selectors', () => {
       });
     });
   });
+  describe('assignmentGradeFilterValidity', () => {
+    it('returns true iff the value is between 0 and 100 (inclusive)', () => {
+      const testSelector = (assignmentGradeMax, isMaxValid, assignmentGradeMin, isMinValid, isMinLessMaxValid) => {
+        expect(selectors.assignmentGradeFilterValidity({
+          ...testState,
+          app: {
+            ...testState.app,
+            filters: { ...testState.filters, assignmentGradeMax, assignmentGradeMin },
+          },
+        })).toEqual({ isMaxValid, isMinValid, isMinLessMaxValid });
+      };
+      testSelector(-1, false, 0, true, false);
+      testSelector(0, true, -1, false, true);
+      testSelector(100, true, 101, false, false);
+      testSelector(101, false, 100, true, true);
+    });
+  });
   describe('courseGradeFilterValidity', () => {
     it('returns true iff the value is between 0 and 100 (inclusive)', () => {
-      const testSelector = (courseGradeMax, isMaxValid, courseGradeMin, isMinValid) => {
+      const testSelector = (courseGradeMax, isMaxValid, courseGradeMin, isMinValid, isMinLessMaxValid) => {
         expect(selectors.courseGradeFilterValidity({
           ...testState,
           app: {
             ...testState.app,
             filters: { ...testState.filters, courseGradeMax, courseGradeMin },
           },
-        })).toEqual({ isMaxValid, isMinValid });
+        })).toEqual({ isMaxValid, isMinValid, isMinLessMaxValid });
       };
-      testSelector(-1, false, 0, true);
-      testSelector(0, true, -1, false);
-      testSelector(100, true, 101, false);
-      testSelector(101, false, 100, true);
+      testSelector(-1, false, 0, true, false);
+      testSelector(0, true, -1, false, true);
+      testSelector(100, true, 101, false, false);
+      testSelector(101, false, 100, true, true);
     });
   });
   describe('courseGradeLimits', () => {
@@ -75,20 +92,44 @@ describe('app selectors', () => {
       }]);
     });
   });
+  describe('areAssignmentGradeFiltersValid', () => {
+    const mockValidity = (isMinValid, isMaxValid, isMinLessMaxValid) => {
+      selectors.assignmentGradeFilterValidity = jest.fn(() => ({
+        isMinValid,
+        isMaxValid,
+        isMinLessMaxValid,
+      }));
+    };
+    it('returns true iff assignmentGrade filters are both valid', () => {
+      const old = selectors.assignmentGradeFilterValidity;
+      mockValidity(true, false, false);
+      expect(exportedSelectors.areAssignmentGradeFiltersValid(testState)).toEqual(false);
+      mockValidity(false, true, false);
+      expect(exportedSelectors.areAssignmentGradeFiltersValid(testState)).toEqual(false);
+      mockValidity(false, false, true);
+      expect(exportedSelectors.areAssignmentGradeFiltersValid(testState)).toEqual(false);
+      mockValidity(true, true, true);
+      expect(exportedSelectors.areAssignmentGradeFiltersValid(testState)).toEqual(true);
+      selectors.assignmentGradeFilterValidity = old;
+    });
+  });
   describe('areCourseGradeFiltersValid', () => {
-    const mockValidity = (isMinValid, isMaxValid) => {
+    const mockValidity = (isMinValid, isMaxValid, isMinLessMaxValid) => {
       selectors.courseGradeFilterValidity = jest.fn(() => ({
         isMinValid,
         isMaxValid,
+        isMinLessMaxValid,
       }));
     };
     it('returns true iff courseGrade filters are both valid', () => {
       const old = selectors.courseGradeFilterValidity;
-      mockValidity(false, true);
+      mockValidity(true, false, false);
+      expect(exportedSelectors.areCourseGradeFiltersValid(testState)).toEqual(false);
+      mockValidity(false, true, false);
       expect(exportedSelectors.areCourseGradeFiltersValid(testState)).toEqual(false);
-      mockValidity(true, false);
+      mockValidity(false, false, true);
       expect(exportedSelectors.areCourseGradeFiltersValid(testState)).toEqual(false);
-      mockValidity(true, true);
+      mockValidity(true, true, true);
       expect(exportedSelectors.areCourseGradeFiltersValid(testState)).toEqual(true);
       selectors.courseGradeFilterValidity = old;
     });