Respond to PR feedback and add tests

packages/core/components/AnnotationFilterForm/index.tsx

@@ -39,19 +39,21 @@ export default function AnnotationFilterForm(props: AnnotationFilterFormProps) {
         annotationService
     );
 
-    const fuzzySearchEnabled = React.useMemo(() => {
-        return !!fuzzyFilters?.some((filter) => filter.name === props.annotation.name);
-    }, [fuzzyFilters, props.annotation]);
+    const fuzzySearchEnabled = React.useMemo(
+        () => !!fuzzyFilters?.some((filter) => filter.name === props.annotation.name),
+        [fuzzyFilters, props.annotation]
+    );
 
     const filtersForAnnotation = React.useMemo(
         () => allFilters.filter((filter) => filter.name === props.annotation.name),
         [allFilters, props.annotation]
     );
 
     // Assume all filters use same type
-    const defaultFilterType = React.useMemo(() => {
-        return filtersForAnnotation?.[0]?.type ?? FilterType.DEFAULT;
-    }, [filtersForAnnotation]);
+    const defaultFilterType = React.useMemo(
+        () => filtersForAnnotation?.[0]?.type ?? FilterType.DEFAULT,
+        [filtersForAnnotation]
+    );
 
     const [filterType, setFilterType] = React.useState<FilterType>(defaultFilterType);
 
@@ -96,7 +98,7 @@ export default function AnnotationFilterForm(props: AnnotationFilterFormProps) {
         );
     };
 
-    const _onFilterTypeOptionChange = (option: IChoiceGroupOption | undefined) => {
+    const onFilterTypeOptionChange = (option: IChoiceGroupOption | undefined) => {
         // Verify that filter type is changing to avoid dispatching unnecessary clean-up actions
         if (!!option?.key && option?.key !== filterType) {
             setFilterType(option.key as FilterType);
@@ -230,7 +232,7 @@ export default function AnnotationFilterForm(props: AnnotationFilterFormProps) {
                             text: "No value (blank)",
                         },
                     ]}
-                    onChange={(_, option) => _onFilterTypeOptionChange(option)}
+                    onChange={(_, option) => onFilterTypeOptionChange(option)}
                 />
             </div>
             {filterType === FilterType.DEFAULT || filterType === FilterType.FUZZY ? (

packages/core/entity/FileFilter/test/FileFilter.test.ts

@@ -0,0 +1,76 @@
+import { expect } from "chai";
+
+import FileFilter, { FilterType } from "../";
+import IncludeFilter from "../IncludeFilter";
+import ExcludeFilter from "../ExcludeFilter";
+import FuzzyFilter from "../FuzzyFilter";
+
+describe("FileFilter", () => {
+    describe("equals", () => {
+        it("is backwards compatible when no type argument is provided", () => {
+            // Arrange
+            const fileFilterNoType = new FileFilter("Annotation name", "test value");
+            const fileFilterWithType = new FileFilter(
+                "Annotation name",
+                "test value",
+                FilterType.DEFAULT
+            );
+
+            // Act/Assert
+            expect(fileFilterNoType.equals(fileFilterWithType));
+        });
+        it("returns true for include filter subtype and parent class", () => {
+            // Arrange
+            const fileFilterIncludeConstructor = new IncludeFilter("Annotation name");
+            const fileFilterParentConstructor = new FileFilter(
+                "Annotation name",
+                "",
+                FilterType.ANY
+            );
+
+            // Act/Assert
+            expect(fileFilterIncludeConstructor.equals(fileFilterParentConstructor));
+        });
+        it("returns true for exclude filter subtype and parent class", () => {
+            // Arrange
+            const fileFilterExcludeConstructor = new ExcludeFilter("Annotation name");
+            const fileFilterParentConstructor = new FileFilter(
+                "Annotation name",
+                "",
+                FilterType.EXCLUDE
+            );
+
+            // Act/Assert
+            expect(fileFilterExcludeConstructor.equals(fileFilterParentConstructor));
+        });
+        it("returns true for fuzzy filter subtype and parent class", () => {
+            // Arrange
+            const fileFilterFuzzyConstructor = new FuzzyFilter(
+                "Annotation name",
+                "annotation value"
+            );
+            const fileFilterParentConstructor = new FileFilter(
+                "Annotation name",
+                "annotation value",
+                FilterType.FUZZY
+            );
+
+            // Act/Assert
+            expect(fileFilterFuzzyConstructor.equals(fileFilterParentConstructor));
+        });
+        it("returns false for different filter subtypes", () => {
+            // Arrange
+            const fileFilter = new FileFilter("Annotation name", "annotation value");
+            const fileFilterFuzzyConstructor = new FuzzyFilter(
+                "Annotation name",
+                "annotation value"
+            );
+            const fileFilterExcludeConstructor = new ExcludeFilter("Annotation name");
+            const fileFilterIncludeConstructor = new IncludeFilter("Annotation name");
+
+            // Act/Assert
+            expect(!fileFilterFuzzyConstructor.equals(fileFilter));
+            expect(!fileFilterIncludeConstructor.equals(fileFilterExcludeConstructor));
+        });
+    });
+});