@dhis2-ui/transfer 10.13.1 → 10.14.0

package/build/es/__tests__/helper/default-filter-callback.test.js

@@ -37,4 +37,10 @@ describe('Transfer - defaultFilterCallback', () => {
     const actual = defaultFilterCallback(options, filter);
     expect(actual).toEqual(expected);
   });
+  it('should return all options when the filter is invalid regexp', () => {
+    const filter = '(';
+    const expected = options;
+    const actual = defaultFilterCallback(options, filter);
+    expect(actual).toEqual(expected);
+  });
 });

package/build/es/__tests__/helper/is-reorder-down-disabled.test.js

@@ -2,35 +2,74 @@ import { isReorderDownDisabled } from '../../transfer/is-reorder-down-disabled.j
 describe('Transfer - isReorderDownDisabled', () => {
   const selected = ['foo', 'bar', 'baz'];
   it('should return true when there are no highlighted picked options', () => {
-    const highlightedPickedOptions = [];
     const actual = isReorderDownDisabled({
-      highlightedPickedOptions,
+      highlightedPickedOptions: [],
       selected
     });
     expect(actual).toBe(true);
   });
-  it('should return true when there are multiple highlighted picked options', () => {
-    const highlightedPickedOptions = ['bar', 'foo'];
+  it('should return true if the last picked option is the only highlighted one', () => {
     const actual = isReorderDownDisabled({
-      highlightedPickedOptions,
+      highlightedPickedOptions: ['baz'],
       selected
     });
     expect(actual).toBe(true);
   });
-  it('should return true if the last picked option is highlighted', () => {
-    const highlightedPickedOptions = ['baz'];
+  it('should return false when one picked option is highlighted which is not the last one', () => {
+    const actual = isReorderDownDisabled({
+      highlightedPickedOptions: ['bar'],
+      selected
+    });
+    expect(actual).toBe(false);
+  });
+  it('should return false for a contiguous multi-select not flush to the bottom', () => {
+    const actual = isReorderDownDisabled({
+      highlightedPickedOptions: ['foo', 'bar'],
+      selected
+    });
+    expect(actual).toBe(false);
+  });
+  it('should return true for a contiguous multi-select flush to the bottom', () => {
     const actual = isReorderDownDisabled({
-      highlightedPickedOptions,
+      highlightedPickedOptions: ['bar', 'baz'],
       selected
     });
     expect(actual).toBe(true);
   });
-  it('should return false when one picked option is highlighted which is not the last one', () => {
-    const highlightedPickedOptions = ['bar'];
+  it('should return true when all items are highlighted', () => {
     const actual = isReorderDownDisabled({
-      highlightedPickedOptions,
+      highlightedPickedOptions: ['foo', 'bar', 'baz'],
+      selected
+    });
+    expect(actual).toBe(true);
+  });
+  it('should return false for a non-contiguous selection containing the last item', () => {
+    const actual = isReorderDownDisabled({
+      highlightedPickedOptions: ['foo', 'baz'],
+      selected
+    });
+    expect(actual).toBe(false);
+  });
+  it('should ignore highlighted values that do not exist in selected', () => {
+    const actual = isReorderDownDisabled({
+      highlightedPickedOptions: ['ghost', 'foo'],
       selected
     });
     expect(actual).toBe(false);
   });
+  it('should return true when all highlighted values are missing from selected', () => {
+    const actual = isReorderDownDisabled({
+      highlightedPickedOptions: ['ghost'],
+      selected
+    });
+    expect(actual).toBe(true);
+  });
+  it('should return true when a filter is active on the picked side', () => {
+    const actual = isReorderDownDisabled({
+      highlightedPickedOptions: ['foo'],
+      selected,
+      filterActivePicked: true
+    });
+    expect(actual).toBe(true);
+  });
 });

package/build/es/__tests__/helper/is-reorder-up-disabled.test.js

@@ -2,35 +2,74 @@ import { isReorderUpDisabled } from '../../transfer/is-reorder-up-disabled.js';
 describe('Transfer - isReorderUpDisabled', () => {
   const selected = ['foo', 'bar', 'baz'];
   it('should return true when there are no highlighted picked options', () => {
-    const highlightedPickedOptions = [];
     const actual = isReorderUpDisabled({
-      highlightedPickedOptions,
+      highlightedPickedOptions: [],
       selected
     });
     expect(actual).toBe(true);
   });
-  it('should return true when there are multiple highlighted picked options', () => {
-    const highlightedPickedOptions = ['bar', 'baz'];
+  it('should return true if the first picked option is the only highlighted one', () => {
     const actual = isReorderUpDisabled({
-      highlightedPickedOptions,
+      highlightedPickedOptions: ['foo'],
       selected
     });
     expect(actual).toBe(true);
   });
-  it('should return true if the first picked option is highlighted', () => {
-    const highlightedPickedOptions = ['foo'];
+  it('should return false when one picked option is highlighted which is not the first one', () => {
     const actual = isReorderUpDisabled({
-      highlightedPickedOptions,
+      highlightedPickedOptions: ['baz'],
+      selected
+    });
+    expect(actual).toBe(false);
+  });
+  it('should return false for a contiguous multi-select not flush to the top', () => {
+    const actual = isReorderUpDisabled({
+      highlightedPickedOptions: ['bar', 'baz'],
+      selected
+    });
+    expect(actual).toBe(false);
+  });
+  it('should return true for a contiguous multi-select flush to the top', () => {
+    const actual = isReorderUpDisabled({
+      highlightedPickedOptions: ['foo', 'bar'],
+      selected
+    });
+    expect(actual).toBe(true);
+  });
+  it('should return true when all items are highlighted', () => {
+    const actual = isReorderUpDisabled({
+      highlightedPickedOptions: ['foo', 'bar', 'baz'],
       selected
     });
     expect(actual).toBe(true);
   });
-  it('should return false when one picked option is highlighted which is not the last one', () => {
-    const highlightedPickedOptions = ['baz'];
+  it('should return false for a non-contiguous selection containing the first item', () => {
     const actual = isReorderUpDisabled({
-      highlightedPickedOptions,
+      highlightedPickedOptions: ['foo', 'baz'],
       selected
     });
     expect(actual).toBe(false);
   });
+  it('should ignore highlighted values that do not exist in selected', () => {
+    const actual = isReorderUpDisabled({
+      highlightedPickedOptions: ['ghost', 'baz'],
+      selected
+    });
+    expect(actual).toBe(false);
+  });
+  it('should return true when all highlighted values are missing from selected', () => {
+    const actual = isReorderUpDisabled({
+      highlightedPickedOptions: ['ghost'],
+      selected
+    });
+    expect(actual).toBe(true);
+  });
+  it('should return true when a filter is active on the picked side', () => {
+    const actual = isReorderUpDisabled({
+      highlightedPickedOptions: ['baz'],
+      selected,
+      filterActivePicked: true
+    });
+    expect(actual).toBe(true);
+  });
 });

package/build/es/__tests__/helper/move-highlighted-picked-option-down.test.js

@@ -1,15 +1,13 @@
 import { moveHighlightedPickedOptionDown } from '../../transfer/move-highlighted-picked-option-down.js';
 describe('Transfer - moveHighlightedPickedOptionDown', () => {
   const onChange = jest.fn();
-  const selected = ['foo', 'bar', 'baz'];
   afterEach(() => {
     onChange.mockClear();
   });
-  it('should move the highlighted option down', () => {
-    const highlighted = ['bar'];
+  it('should move a single highlighted option down', () => {
     moveHighlightedPickedOptionDown({
-      selected,
-      highlightedPickedOptions: highlighted,
+      selected: ['foo', 'bar', 'baz'],
+      highlightedPickedOptions: ['bar'],
       onChange
     });
     expect(onChange).toHaveBeenCalledWith({
@@ -17,21 +15,77 @@ describe('Transfer - moveHighlightedPickedOptionDown', () => {
     });
   });
   it('should do nothing when trying to move down the last option', () => {
-    const highlighted = ['baz'];
     moveHighlightedPickedOptionDown({
-      selected,
-      highlightedPickedOptions: highlighted,
+      selected: ['foo', 'bar', 'baz'],
+      highlightedPickedOptions: ['baz'],
       onChange
     });
     expect(onChange).toHaveBeenCalledTimes(0);
   });
   it('should do nothing when trying to move down a non-existing option', () => {
-    const highlighted = ['foobar'];
     moveHighlightedPickedOptionDown({
-      selected,
-      highlightedPickedOptions: highlighted,
+      selected: ['foo', 'bar', 'baz'],
+      highlightedPickedOptions: ['ghost'],
       onChange
     });
     expect(onChange).toHaveBeenCalledTimes(0);
   });
+  it('should shift a contiguous block of highlighted options down as a group', () => {
+    moveHighlightedPickedOptionDown({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['b', 'c'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'd', 'b', 'c', 'e']
+    });
+  });
+  it('should collapse and shift a non-contiguous selection down in one call', () => {
+    moveHighlightedPickedOptionDown({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['b', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'e', 'b', 'd']
+    });
+  });
+  it('should preserve the relative order of highlighted items regardless of input order', () => {
+    moveHighlightedPickedOptionDown({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['d', 'b'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'e', 'b', 'd']
+    });
+  });
+  it('should collapse a non-contiguous selection containing the last item without shifting past the end', () => {
+    moveHighlightedPickedOptionDown({
+      selected: ['a', 'b', 'c'],
+      highlightedPickedOptions: ['a', 'c'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['b', 'a', 'c']
+    });
+  });
+  it('should do nothing when the highlighted block is already flush to the bottom', () => {
+    moveHighlightedPickedOptionDown({
+      selected: ['a', 'b', 'c', 'd'],
+      highlightedPickedOptions: ['c', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledTimes(0);
+  });
+  it('should ignore highlighted values that do not exist in selected', () => {
+    moveHighlightedPickedOptionDown({
+      selected: ['a', 'b', 'c'],
+      highlightedPickedOptions: ['ghost', 'a'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['b', 'a', 'c']
+    });
+  });
 });

package/build/es/__tests__/helper/move-highlighted-picked-option-to-bottom.test.js

@@ -0,0 +1,83 @@
+import { moveHighlightedPickedOptionToBottom } from '../../transfer/move-highlighted-picked-option-to-bottom.js';
+describe('Transfer - moveHighlightedPickedOptionToBottom', () => {
+  const onChange = jest.fn();
+  afterEach(() => {
+    onChange.mockClear();
+  });
+  it('should move a single highlighted option to the bottom', () => {
+    moveHighlightedPickedOptionToBottom({
+      selected: ['a', 'b', 'c', 'd'],
+      highlightedPickedOptions: ['b'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'd', 'b']
+    });
+  });
+  it('should move a contiguous block to the bottom as a group', () => {
+    moveHighlightedPickedOptionToBottom({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['b', 'c'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'd', 'e', 'b', 'c']
+    });
+  });
+  it('should collapse a non-contiguous selection to the bottom preserving relative order', () => {
+    moveHighlightedPickedOptionToBottom({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['b', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'e', 'b', 'd']
+    });
+  });
+  it('should preserve relative order regardless of highlight input order', () => {
+    moveHighlightedPickedOptionToBottom({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['d', 'b'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'e', 'b', 'd']
+    });
+  });
+  it('should do nothing when the highlighted block is already flush to the bottom', () => {
+    moveHighlightedPickedOptionToBottom({
+      selected: ['a', 'b', 'c', 'd'],
+      highlightedPickedOptions: ['c', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledTimes(0);
+  });
+  it('should still run when the selection includes the bottom item but has a gap', () => {
+    moveHighlightedPickedOptionToBottom({
+      selected: ['a', 'b', 'c', 'd'],
+      highlightedPickedOptions: ['b', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'b', 'd']
+    });
+  });
+  it('should do nothing when no highlighted options exist in selected', () => {
+    moveHighlightedPickedOptionToBottom({
+      selected: ['a', 'b', 'c'],
+      highlightedPickedOptions: ['ghost'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledTimes(0);
+  });
+  it('should ignore highlighted values that do not exist in selected', () => {
+    moveHighlightedPickedOptionToBottom({
+      selected: ['a', 'b', 'c'],
+      highlightedPickedOptions: ['ghost', 'a'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['b', 'c', 'a']
+    });
+  });
+});

package/build/es/__tests__/helper/move-highlighted-picked-option-to-top.test.js

@@ -0,0 +1,83 @@
+import { moveHighlightedPickedOptionToTop } from '../../transfer/move-highlighted-picked-option-to-top.js';
+describe('Transfer - moveHighlightedPickedOptionToTop', () => {
+  const onChange = jest.fn();
+  afterEach(() => {
+    onChange.mockClear();
+  });
+  it('should move a single highlighted option to the top', () => {
+    moveHighlightedPickedOptionToTop({
+      selected: ['a', 'b', 'c', 'd'],
+      highlightedPickedOptions: ['c'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['c', 'a', 'b', 'd']
+    });
+  });
+  it('should move a contiguous block to the top as a group', () => {
+    moveHighlightedPickedOptionToTop({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['c', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['c', 'd', 'a', 'b', 'e']
+    });
+  });
+  it('should collapse a non-contiguous selection to the top preserving relative order', () => {
+    moveHighlightedPickedOptionToTop({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['b', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['b', 'd', 'a', 'c', 'e']
+    });
+  });
+  it('should preserve relative order regardless of highlight input order', () => {
+    moveHighlightedPickedOptionToTop({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['d', 'b'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['b', 'd', 'a', 'c', 'e']
+    });
+  });
+  it('should do nothing when the highlighted block is already flush to the top', () => {
+    moveHighlightedPickedOptionToTop({
+      selected: ['a', 'b', 'c', 'd'],
+      highlightedPickedOptions: ['a', 'b'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledTimes(0);
+  });
+  it('should still run when the selection includes the top item but has a gap', () => {
+    moveHighlightedPickedOptionToTop({
+      selected: ['a', 'b', 'c', 'd'],
+      highlightedPickedOptions: ['a', 'c'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'b', 'd']
+    });
+  });
+  it('should do nothing when no highlighted options exist in selected', () => {
+    moveHighlightedPickedOptionToTop({
+      selected: ['a', 'b', 'c'],
+      highlightedPickedOptions: ['ghost'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledTimes(0);
+  });
+  it('should ignore highlighted values that do not exist in selected', () => {
+    moveHighlightedPickedOptionToTop({
+      selected: ['a', 'b', 'c'],
+      highlightedPickedOptions: ['ghost', 'c'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['c', 'a', 'b']
+    });
+  });
+});

package/build/es/__tests__/helper/move-highlighted-picked-option-up.test.js

@@ -1,15 +1,13 @@
 import { moveHighlightedPickedOptionUp } from '../../transfer/move-highlighted-picked-option-up.js';
 describe('Transfer - moveHighlightedPickedOptionUp', () => {
   const onChange = jest.fn();
-  const selected = ['foo', 'bar', 'baz'];
   afterEach(() => {
     onChange.mockClear();
   });
-  it('should move the highlighted option up', () => {
-    const highlighted = ['bar'];
+  it('should move a single highlighted option up', () => {
     moveHighlightedPickedOptionUp({
-      selected,
-      highlightedPickedOptions: highlighted,
+      selected: ['foo', 'bar', 'baz'],
+      highlightedPickedOptions: ['bar'],
       onChange
     });
     expect(onChange).toHaveBeenCalledWith({
@@ -17,21 +15,77 @@ describe('Transfer - moveHighlightedPickedOptionUp', () => {
     });
   });
   it('should do nothing when trying to move up the first option', () => {
-    const highlighted = ['foo'];
     moveHighlightedPickedOptionUp({
-      selected,
-      highlightedPickedOptions: highlighted,
+      selected: ['foo', 'bar', 'baz'],
+      highlightedPickedOptions: ['foo'],
       onChange
     });
     expect(onChange).toHaveBeenCalledTimes(0);
   });
   it('should do nothing when trying to move up a non-existing option', () => {
-    const highlighted = ['foobar'];
     moveHighlightedPickedOptionUp({
-      selected,
-      highlightedPickedOptions: highlighted,
+      selected: ['foo', 'bar', 'baz'],
+      highlightedPickedOptions: ['ghost'],
       onChange
     });
     expect(onChange).toHaveBeenCalledTimes(0);
   });
+  it('should shift a contiguous block of highlighted options up as a group', () => {
+    moveHighlightedPickedOptionUp({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['c', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'd', 'b', 'e']
+    });
+  });
+  it('should collapse and shift a non-contiguous selection up in one call', () => {
+    moveHighlightedPickedOptionUp({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['b', 'd'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['b', 'd', 'a', 'c', 'e']
+    });
+  });
+  it('should preserve the relative order of highlighted items regardless of input order', () => {
+    moveHighlightedPickedOptionUp({
+      selected: ['a', 'b', 'c', 'd', 'e'],
+      highlightedPickedOptions: ['d', 'b'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['b', 'd', 'a', 'c', 'e']
+    });
+  });
+  it('should collapse a non-contiguous selection containing the first item without shifting past index 0', () => {
+    moveHighlightedPickedOptionUp({
+      selected: ['a', 'b', 'c'],
+      highlightedPickedOptions: ['a', 'c'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'b']
+    });
+  });
+  it('should do nothing when the highlighted block is already flush to the top', () => {
+    moveHighlightedPickedOptionUp({
+      selected: ['a', 'b', 'c', 'd'],
+      highlightedPickedOptions: ['a', 'b'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledTimes(0);
+  });
+  it('should ignore highlighted values that do not exist in selected', () => {
+    moveHighlightedPickedOptionUp({
+      selected: ['a', 'b', 'c'],
+      highlightedPickedOptions: ['ghost', 'c'],
+      onChange
+    });
+    expect(onChange).toHaveBeenCalledWith({
+      selected: ['a', 'c', 'b']
+    });
+  });
 });

package/build/es/__tests__/reordering-actions.test.js

@@ -0,0 +1,101 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import { mount } from 'enzyme';
+import React from 'react';
+import { ReorderingActions } from '../reordering-actions.js';
+const findButton = (wrapper, dataTest) => wrapper.find(`button[data-test="${dataTest}"]`);
+const allButtonHooks = dataTest => [`${dataTest}-buttonmovetotop`, `${dataTest}-buttonmoveup`, `${dataTest}-buttonmovedown`, `${dataTest}-buttonmovetobottom`];
+describe('Transfer - ReorderingActions', () => {
+  const dataTest = 'test-reorderingactions';
+  const baseProps = {
+    dataTest,
+    onChangeUp: jest.fn(),
+    onChangeDown: jest.fn(),
+    onChangeToTop: jest.fn(),
+    onChangeToBottom: jest.fn()
+  };
+  afterEach(() => {
+    Object.values(baseProps).forEach(value => {
+      if (jest.isMockFunction(value)) {
+        value.mockClear();
+      }
+    });
+  });
+  it('renders all four reorder buttons', () => {
+    const wrapper = mount(/*#__PURE__*/React.createElement(ReorderingActions, baseProps));
+    expect(findButton(wrapper, `${dataTest}-buttonmovetotop`)).toHaveLength(1);
+    expect(findButton(wrapper, `${dataTest}-buttonmoveup`)).toHaveLength(1);
+    expect(findButton(wrapper, `${dataTest}-buttonmovedown`)).toHaveLength(1);
+    expect(findButton(wrapper, `${dataTest}-buttonmovetobottom`)).toHaveLength(1);
+  });
+  it('invokes the corresponding handler for each button', () => {
+    const wrapper = mount(/*#__PURE__*/React.createElement(ReorderingActions, baseProps));
+    findButton(wrapper, `${dataTest}-buttonmovetotop`).simulate('click');
+    expect(baseProps.onChangeToTop).toHaveBeenCalledTimes(1);
+    findButton(wrapper, `${dataTest}-buttonmoveup`).simulate('click');
+    expect(baseProps.onChangeUp).toHaveBeenCalledTimes(1);
+    findButton(wrapper, `${dataTest}-buttonmovedown`).simulate('click');
+    expect(baseProps.onChangeDown).toHaveBeenCalledTimes(1);
+    findButton(wrapper, `${dataTest}-buttonmovetobottom`).simulate('click');
+    expect(baseProps.onChangeToBottom).toHaveBeenCalledTimes(1);
+  });
+  it('does not cross-fire handlers when a single button is clicked', () => {
+    const wrapper = mount(/*#__PURE__*/React.createElement(ReorderingActions, baseProps));
+    findButton(wrapper, `${dataTest}-buttonmoveup`).simulate('click');
+    expect(baseProps.onChangeUp).toHaveBeenCalledTimes(1);
+    expect(baseProps.onChangeDown).not.toHaveBeenCalled();
+    expect(baseProps.onChangeToTop).not.toHaveBeenCalled();
+    expect(baseProps.onChangeToBottom).not.toHaveBeenCalled();
+  });
+  it('disables both up-side buttons when disabledUp is true', () => {
+    const wrapper = mount(/*#__PURE__*/React.createElement(ReorderingActions, _extends({}, baseProps, {
+      disabledUp: true
+    })));
+    expect(findButton(wrapper, `${dataTest}-buttonmovetotop`).prop('disabled')).toBe(true);
+    expect(findButton(wrapper, `${dataTest}-buttonmoveup`).prop('disabled')).toBe(true);
+    expect(findButton(wrapper, `${dataTest}-buttonmovedown`).prop('disabled')).toBeFalsy();
+    expect(findButton(wrapper, `${dataTest}-buttonmovetobottom`).prop('disabled')).toBeFalsy();
+  });
+  it('disables both down-side buttons when disabledDown is true', () => {
+    const wrapper = mount(/*#__PURE__*/React.createElement(ReorderingActions, _extends({}, baseProps, {
+      disabledDown: true
+    })));
+    expect(findButton(wrapper, `${dataTest}-buttonmovedown`).prop('disabled')).toBe(true);
+    expect(findButton(wrapper, `${dataTest}-buttonmovetobottom`).prop('disabled')).toBe(true);
+    expect(findButton(wrapper, `${dataTest}-buttonmoveup`).prop('disabled')).toBeFalsy();
+    expect(findButton(wrapper, `${dataTest}-buttonmovetotop`).prop('disabled')).toBeFalsy();
+  });
+  it('does not invoke handlers for disabled buttons', () => {
+    const wrapper = mount(/*#__PURE__*/React.createElement(ReorderingActions, _extends({}, baseProps, {
+      disabledUp: true,
+      disabledDown: true
+    })));
+    findButton(wrapper, `${dataTest}-buttonmovetotop`).simulate('click');
+    findButton(wrapper, `${dataTest}-buttonmoveup`).simulate('click');
+    findButton(wrapper, `${dataTest}-buttonmovedown`).simulate('click');
+    findButton(wrapper, `${dataTest}-buttonmovetobottom`).simulate('click');
+    expect(baseProps.onChangeToTop).not.toHaveBeenCalled();
+    expect(baseProps.onChangeUp).not.toHaveBeenCalled();
+    expect(baseProps.onChangeDown).not.toHaveBeenCalled();
+    expect(baseProps.onChangeToBottom).not.toHaveBeenCalled();
+  });
+  it('sets aria-label on every button', () => {
+    const wrapper = mount(/*#__PURE__*/React.createElement(ReorderingActions, baseProps));
+    const assertLabel = (hook, label) => {
+      expect(findButton(wrapper, hook).prop('aria-label')).toBe(label);
+    };
+    assertLabel(`${dataTest}-buttonmovetotop`, 'Move selected items to top');
+    assertLabel(`${dataTest}-buttonmoveup`, 'Move selected items up');
+    assertLabel(`${dataTest}-buttonmovedown`, 'Move selected items down');
+    assertLabel(`${dataTest}-buttonmovetobottom`, 'Move selected items to bottom');
+  });
+  it('still renders and wires up all four buttons when filterActive is true', () => {
+    const wrapper = mount(/*#__PURE__*/React.createElement(ReorderingActions, _extends({}, baseProps, {
+      filterActive: true
+    })));
+    allButtonHooks(dataTest).forEach(hook => {
+      expect(findButton(wrapper, hook)).toHaveLength(1);
+    });
+    findButton(wrapper, `${dataTest}-buttonmoveup`).simulate('click');
+    expect(baseProps.onChangeUp).toHaveBeenCalledTimes(1);
+  });
+});