text: import {
      getPossibleReferenceValues,
      getPossibleReferences,
  } from './possibleValues';
  
  describe('possibleValues reducer', () => {
      describe('getPossibleReferenceValues selector', () => {
          it('should return references', () => {
              const state = {
                  'foo@bar': [1, 2, 3],
              };
              const props = {
                  resource: 'foo',
                  source: 'bar',
                  referenceSource: (resource, source) => `${resource}@${source}`,
              };
              expect(getPossibleReferenceValues(state, props)).toEqual([1, 2, 3]);
          });
      });
  
      describe('getPossibleReferences', () => {
          const referenceState = {
              data: {
                  1: { name: 'object name 1' },
                  2: { name: 'object name 2' },
                  3: { name: 'object name 3' },
                  4: { name: 'object name 4' },
                  5: { name: 'object name 5' },
              },
          };
          it('should return null if there is no possibleValues available in state', () => {
              const possibleReferences = getPossibleReferences(
                  referenceState,
                  null
              );
              expect(possibleReferences).toEqual(null);
          });
  
          it('should return an object with error if the possibleValues in state is an error', () => {
              const possibleReferences = getPossibleReferences(referenceState, {
                  error: 'error message',
              });
              expect(possibleReferences).toEqual({ error: 'error message' });
          });
  
          it('should return a empty array if the possibleValues in state is empty', () => {
              const possibleReferences = getPossibleReferences(
                  referenceState,
                  []
              );
              expect(possibleReferences).toEqual([]);
          });
  
          it('should return all formated possibleValues in state if selectedIds param is not set', () => {
              const possibleReferences = getPossibleReferences(referenceState, [
                  1,
                  2,
                  4,
              ]);
              expect(possibleReferences).toEqual([
                  { name: 'object name 1' },
                  { name: 'object name 2' },
                  { name: 'object name 4' },
              ]);
          });
  
          it('should return all formated possibleValues in state if selectedIds param is an empty array', () => {
              const possibleReferences = getPossibleReferences(
                  referenceState,
                  [1, 2, 4],
                  []
              );
              expect(possibleReferences).toEqual([
                  { name: 'object name 1' },
                  { name: 'object name 2' },
                  { name: 'object name 4' },
              ]);
          });
  
          it('should add selectedIds to the formated possibleValues in state if it is not already in', () => {
              const possibleReferences = getPossibleReferences(
                  referenceState,
                  [1, 2, 4],
                  [1, 5]
              );
              expect(possibleReferences).toEqual([
                  { name: 'object name 5' },
                  { name: 'object name 1' },
                  { name: 'object name 2' },
                  { name: 'object name 4' },
              ]);
          });
      });
  });
  