react-native-navigation 8.4.3 → 8.5.0

package/lib/module/commands/OptionsProcessor.test.js

@@ -0,0 +1,1234 @@
+"use strict";
+
+import { OptionsProcessor } from "./OptionsProcessor.js";
+import { UniqueIdProvider } from "../adapters/UniqueIdProvider.js";
+import { Store } from "../components/Store.js";
+import { OptionProcessorsStore } from "../processors/OptionProcessorsStore.js";
+import { OptionsModalPresentationStyle } from "../interfaces/Options.js";
+import { mock, when, instance, anyNumber, verify, anything } from 'ts-mockito';
+import { ColorService } from "../adapters/ColorService.js";
+import { AssetService } from "../adapters/AssetResolver.js";
+import { Deprecations } from "./Deprecations.js";
+import { CommandName } from "../interfaces/CommandName.js";
+import { DynamicColorIOS, Platform } from 'react-native';
+describe('navigation options', () => {
+  let uut;
+  let optionProcessorsRegistry;
+  const mockedStore = mock(Store);
+  const store = instance(mockedStore);
+  beforeEach(() => {
+    const mockedAssetService = mock(AssetService);
+    when(mockedAssetService.resolveFromRequire(anyNumber())).thenReturn({
+      height: 100,
+      scale: 1,
+      uri: 'lol',
+      width: 100
+    });
+    const assetService = instance(mockedAssetService);
+    const mockedColorService = mock(ColorService);
+    when(mockedColorService.toNativeColor('red')).thenReturn(0xffff0000);
+    when(mockedColorService.toNativeColor('green')).thenReturn(0xff00ff00);
+    when(mockedColorService.toNativeColor('blue')).thenReturn(0xff0000ff);
+    const colorService = instance(mockedColorService);
+    optionProcessorsRegistry = new OptionProcessorsStore();
+    let uuid = 0;
+    const mockedUniqueIdProvider = mock(UniqueIdProvider);
+    when(mockedUniqueIdProvider.generate(anything())).thenCall(prefix => {
+      return `${prefix}${++uuid}`;
+    });
+    uut = new OptionsProcessor(store, instance(mockedUniqueIdProvider), optionProcessorsRegistry, colorService, assetService, new Deprecations());
+  });
+  it('processes old setRoot animation value to new enter exit format on Android', () => {
+    Platform.OS = 'android';
+    const options = {
+      animations: {
+        setRoot: {
+          enabled: false,
+          translationY: {
+            from: 0,
+            to: 1,
+            duration: 3
+          }
+        }
+      }
+    };
+    const expectedOptions = {
+      animations: {
+        setRoot: {
+          enter: {
+            enabled: false,
+            translationY: {
+              from: 0,
+              to: 1,
+              duration: 3
+            }
+          }
+        }
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual(expectedOptions);
+  });
+  describe('Modal Animation Options', () => {
+    describe('Show Modal', () => {
+      it('processes old options into new options,backwards compatibility ', () => {
+        const options = {
+          animations: {
+            showModal: {
+              enabled: false,
+              translationY: {
+                from: 0,
+                to: 1,
+                duration: 3
+              }
+            },
+            dismissModal: {
+              enabled: true,
+              translationY: {
+                from: 0,
+                to: 1,
+                duration: 3
+              }
+            }
+          }
+        };
+        const expected = {
+          animations: {
+            showModal: {
+              enter: {
+                enabled: false,
+                translationY: {
+                  from: 0,
+                  to: 1,
+                  duration: 3
+                }
+              }
+            },
+            dismissModal: {
+              exit: {
+                enabled: true,
+                translationY: {
+                  from: 0,
+                  to: 1,
+                  duration: 3
+                }
+              }
+            }
+          }
+        };
+        uut.processOptions(CommandName.ShowModal, options);
+        expect(options).toEqual(expected);
+      });
+      it('processes old enabled options into new options,backwards compatibility ', () => {
+        const options = {
+          animations: {
+            showModal: {
+              enabled: false
+            },
+            dismissModal: {
+              enabled: true
+            }
+          }
+        };
+        const expected = {
+          animations: {
+            showModal: {
+              enter: {
+                enabled: false
+              }
+            },
+            dismissModal: {
+              exit: {
+                enabled: true
+              }
+            }
+          }
+        };
+        uut.processOptions(CommandName.ShowModal, options);
+        expect(options).toEqual(expected);
+      });
+      it('should not process new options', () => {
+        const options = {
+          animations: {
+            showModal: {
+              enter: {
+                enabled: false,
+                translationY: {
+                  from: 0,
+                  to: 1,
+                  duration: 3
+                }
+              }
+            },
+            dismissModal: {
+              exit: {
+                enabled: true,
+                translationY: {
+                  from: 0,
+                  to: 1,
+                  duration: 3
+                }
+              }
+            }
+          }
+        };
+        const expected = {
+          ...options
+        };
+        uut.processOptions(CommandName.ShowModal, options);
+        expect(options).toEqual(expected);
+      });
+    });
+    describe('Dismiss Modal', () => {
+      it('processes old options into new options,backwards compatibility ', () => {
+        const options = {
+          animations: {
+            showModal: {
+              enabled: false,
+              translationY: {
+                from: 0,
+                to: 1,
+                duration: 3
+              }
+            },
+            dismissModal: {
+              enabled: true,
+              translationY: {
+                from: 0,
+                to: 1,
+                duration: 3
+              }
+            }
+          }
+        };
+        const expected = {
+          animations: {
+            showModal: {
+              enter: {
+                enabled: false,
+                translationY: {
+                  from: 0,
+                  to: 1,
+                  duration: 3
+                }
+              }
+            },
+            dismissModal: {
+              exit: {
+                enabled: true,
+                translationY: {
+                  from: 0,
+                  to: 1,
+                  duration: 3
+                }
+              }
+            }
+          }
+        };
+        uut.processOptions(CommandName.DismissModal, options);
+        expect(options).toEqual(expected);
+      });
+      it('processes old enabled options into new options,backwards compatibility ', () => {
+        const options = {
+          animations: {
+            showModal: {
+              enabled: false
+            },
+            dismissModal: {
+              enabled: true
+            }
+          }
+        };
+        const expected = {
+          animations: {
+            showModal: {
+              enter: {
+                enabled: false
+              }
+            },
+            dismissModal: {
+              exit: {
+                enabled: true
+              }
+            }
+          }
+        };
+        uut.processOptions(CommandName.DismissModal, options);
+        expect(options).toEqual(expected);
+      });
+      it('should not process new options', () => {
+        const options = {
+          animations: {
+            showModal: {
+              enter: {
+                enabled: false,
+                translationY: {
+                  from: 0,
+                  to: 1,
+                  duration: 3
+                }
+              }
+            },
+            dismissModal: {
+              exit: {
+                enabled: true,
+                translationY: {
+                  from: 0,
+                  to: 1,
+                  duration: 3
+                }
+              }
+            }
+          }
+        };
+        const expected = {
+          ...options
+        };
+        uut.processOptions(CommandName.DismissModal, options);
+        expect(options).toEqual(expected);
+      });
+    });
+  });
+  it('keeps original values if values were not processed', () => {
+    const options = {
+      blurOnUnmount: false,
+      popGesture: false,
+      modalPresentationStyle: OptionsModalPresentationStyle.fullScreen
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      blurOnUnmount: false,
+      popGesture: false,
+      modalPresentationStyle: OptionsModalPresentationStyle.fullScreen
+    });
+  });
+  it('passes value to registered processor', () => {
+    const options = {
+      topBar: {
+        visible: true
+      }
+    };
+    optionProcessorsRegistry.addProcessor('topBar.visible', value => {
+      return !value;
+    });
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      topBar: {
+        visible: false
+      }
+    });
+  });
+  it('process options object with multiple values using registered processor', () => {
+    const options = {
+      topBar: {
+        visible: true,
+        background: {
+          translucent: true
+        }
+      }
+    };
+    optionProcessorsRegistry.addProcessor('topBar.visible', value => {
+      return !value;
+    });
+    optionProcessorsRegistry.addProcessor('topBar.background.translucent', value => {
+      return !value;
+    });
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      topBar: {
+        visible: false,
+        background: {
+          translucent: false
+        }
+      }
+    });
+  });
+  it('passes commandName to registered processor', () => {
+    const options = {
+      topBar: {
+        visible: false
+      }
+    };
+    optionProcessorsRegistry.addProcessor('topBar.visible', (_value, commandName) => {
+      expect(commandName).toEqual(CommandName.SetRoot);
+    });
+    uut.processOptions(CommandName.SetRoot, options);
+  });
+  it('passes props to registered processor', () => {
+    const options = {
+      topBar: {
+        visible: false
+      }
+    };
+    const props = {
+      prop: 'prop'
+    };
+    const processor = (_value, _commandName, passProps) => {
+      expect(passProps).toEqual(props);
+      return _value;
+    };
+    optionProcessorsRegistry.addProcessor('topBar.visible', processor);
+    uut.processOptions(CommandName.SetRoot, options, props);
+  });
+  it('supports multiple registered processors', () => {
+    const options = {
+      topBar: {
+        visible: true
+      }
+    };
+    optionProcessorsRegistry.addProcessor('topBar.visible', () => false);
+    optionProcessorsRegistry.addProcessor('topBar.visible', () => true);
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      topBar: {
+        visible: true
+      }
+    });
+  });
+  it('supports multiple registered processors deep props', () => {
+    const options = {
+      topBar: {
+        visible: false,
+        background: {
+          translucent: false
+        }
+      },
+      bottomTabs: {
+        visible: false
+      }
+    };
+    optionProcessorsRegistry.addProcessor('topBar.visible', () => true);
+    optionProcessorsRegistry.addProcessor('bottomTabs.visible', () => true);
+    optionProcessorsRegistry.addProcessor('topBar.background.translucent', () => true);
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      topBar: {
+        visible: true,
+        background: {
+          translucent: true
+        }
+      },
+      bottomTabs: {
+        visible: true
+      }
+    });
+  });
+  describe('color processor', () => {
+    describe('Android', () => {
+      beforeEach(() => {
+        Platform.OS = 'android';
+      });
+      it('should not process undefined color', () => {
+        const options = {
+          topBar: {
+            background: {
+              color: undefined
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          topBar: {
+            background: {
+              color: undefined
+            }
+          }
+        });
+      });
+      it('PlatformColor should be passed to native as is', () => {
+        const options = {
+          topBar: {
+            background: {
+              color: {
+                // @ts-ignore
+                resource_paths: ['@color/textColor']
+              }
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          topBar: {
+            background: {
+              color: {
+                resource_paths: ['@color/textColor']
+              }
+            }
+          }
+        });
+      });
+      it('processes color keys', () => {
+        const options = {
+          statusBar: {
+            backgroundColor: 'red'
+          },
+          topBar: {
+            background: {
+              color: 'blue'
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          statusBar: {
+            backgroundColor: {
+              light: 0xffff0000,
+              dark: 0xffff0000
+            }
+          },
+          topBar: {
+            background: {
+              color: {
+                light: 0xff0000ff,
+                dark: 0xff0000ff
+              }
+            }
+          }
+        });
+      });
+      it('processes null color', () => {
+        const options = {
+          topBar: {
+            background: {
+              color: null
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          topBar: {
+            background: {
+              color: {
+                light: 'NoColor',
+                dark: 'NoColor'
+              }
+            }
+          }
+        });
+      });
+      it('processes color keys to ThemeColor', () => {
+        const options = {
+          topBar: {
+            background: {
+              color: {
+                light: 'blue',
+                dark: 'red'
+              }
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          topBar: {
+            background: {
+              color: {
+                light: 0xff0000ff,
+                dark: 0xffff0000
+              }
+            }
+          }
+        });
+      });
+    });
+    describe('iOS', () => {
+      beforeEach(() => {
+        Platform.OS = 'ios';
+      });
+      it('processes color keys', () => {
+        const options = {
+          statusBar: {
+            backgroundColor: 'red'
+          },
+          topBar: {
+            background: {
+              color: 'blue'
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          statusBar: {
+            backgroundColor: 0xffff0000
+          },
+          topBar: {
+            background: {
+              color: 0xff0000ff
+            }
+          }
+        });
+      });
+      it('should not process undefined color', () => {
+        const options = {
+          topBar: {
+            background: {
+              color: undefined
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          topBar: {
+            background: {
+              color: undefined
+            }
+          }
+        });
+      });
+      it('processes null color', () => {
+        const options = {
+          topBar: {
+            background: {
+              color: null
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          topBar: {
+            background: {
+              color: 'NoColor'
+            }
+          }
+        });
+      });
+      it('processes color keys to ThemeColor', () => {
+        const options = {
+          statusBar: {
+            backgroundColor: 'red'
+          },
+          topBar: {
+            background: {
+              color: {
+                light: 'blue',
+                dark: 'red'
+              }
+            },
+            title: {
+              color: undefined
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          statusBar: {
+            backgroundColor: 0xffff0000
+          },
+          topBar: {
+            background: {
+              color: {
+                dynamic: {
+                  light: 0xff0000ff,
+                  dark: 0xffff0000
+                }
+              }
+            },
+            title: {
+              color: undefined
+            }
+          }
+        });
+      });
+      it('supports DynamicColorIOS', () => {
+        const options = {
+          topBar: {
+            background: {
+              color: DynamicColorIOS({
+                light: 'red',
+                dark: 'blue'
+              })
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          topBar: {
+            background: {
+              color: {
+                dynamic: {
+                  light: 0xffff0000,
+                  dark: 0xff0000ff
+                }
+              }
+            }
+          }
+        });
+      });
+      it('should not process undefined value', () => {
+        const options = {
+          topBar: {
+            background: {
+              color: undefined
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options).toEqual({
+          topBar: {
+            background: {
+              color: undefined
+            }
+          }
+        });
+      });
+    });
+  });
+  it('processes image keys', () => {
+    const options = {
+      backgroundImage: 123,
+      rootBackgroundImage: 234,
+      bottomTab: {
+        icon: 345,
+        selectedIcon: 345
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      backgroundImage: {
+        height: 100,
+        scale: 1,
+        uri: 'lol',
+        width: 100
+      },
+      rootBackgroundImage: {
+        height: 100,
+        scale: 1,
+        uri: 'lol',
+        width: 100
+      },
+      bottomTab: {
+        icon: {
+          height: 100,
+          scale: 1,
+          uri: 'lol',
+          width: 100
+        },
+        selectedIcon: {
+          height: 100,
+          scale: 1,
+          uri: 'lol',
+          width: 100
+        }
+      }
+    });
+  });
+  it('calls store if component has passProps', () => {
+    const passProps = {
+      some: 'thing'
+    };
+    const options = {
+      topBar: {
+        title: {
+          component: {
+            passProps,
+            name: 'a'
+          }
+        }
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    verify(mockedStore.setPendingProps('CustomComponent1', passProps)).called();
+  });
+  it('generates componentId for component id was not passed', () => {
+    const options = {
+      topBar: {
+        title: {
+          component: {
+            name: 'a'
+          }
+        }
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      topBar: {
+        title: {
+          component: {
+            name: 'a',
+            componentId: 'CustomComponent1'
+          }
+        }
+      }
+    });
+  });
+  it('copies passed id to componentId key', () => {
+    const options = {
+      topBar: {
+        title: {
+          component: {
+            name: 'a',
+            id: 'Component1'
+          }
+        }
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      topBar: {
+        title: {
+          component: {
+            name: 'a',
+            id: 'Component1',
+            componentId: 'Component1'
+          }
+        }
+      }
+    });
+  });
+  it('calls store when button has passProps and id', () => {
+    const passProps = {
+      prop: 'prop'
+    };
+    const options = {
+      topBar: {
+        rightButtons: [{
+          passProps,
+          id: '1'
+        }]
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    verify(mockedStore.setPendingProps('1', passProps)).called();
+  });
+  it('do not touch passProps when id for button is missing', () => {
+    const passProps = {
+      prop: 'prop'
+    };
+    const options = {
+      topBar: {
+        rightButtons: [{
+          passProps
+        }]
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options).toEqual({
+      topBar: {
+        rightButtons: [{
+          passProps
+        }]
+      }
+    });
+  });
+  it('omits passProps when processing buttons or components', () => {
+    const options = {
+      topBar: {
+        rightButtons: [{
+          passProps: {},
+          id: 'btn1'
+        }],
+        leftButtons: [{
+          passProps: {},
+          id: 'btn2'
+        }],
+        title: {
+          component: {
+            name: 'helloThere1',
+            passProps: {}
+          }
+        },
+        background: {
+          component: {
+            name: 'helloThere2',
+            passProps: {}
+          }
+        }
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    expect(options.topBar.rightButtons[0].passProps).toBeUndefined();
+    expect(options.topBar.leftButtons[0].passProps).toBeUndefined();
+    expect(options.topBar.title.component.passProps).toBeUndefined();
+    expect(options.topBar.background.component.passProps).toBeUndefined();
+  });
+  it('Will ensure the store has a chance to lazily load components in options', () => {
+    const options = {
+      topBar: {
+        title: {
+          component: {
+            name: 'helloThere1',
+            passProps: {}
+          }
+        },
+        background: {
+          component: {
+            name: 'helloThere2',
+            passProps: {}
+          }
+        }
+      }
+    };
+    uut.processOptions(CommandName.SetRoot, options);
+    verify(mockedStore.ensureClassForName('helloThere1')).called();
+    verify(mockedStore.ensureClassForName('helloThere2')).called();
+  });
+  it('show warning on iOS when toggling bottomTabs visibility through mergeOptions', () => {
+    jest.spyOn(console, 'warn');
+    uut.processOptions(CommandName.MergeOptions, {
+      bottomTabs: {
+        visible: false
+      }
+    });
+    expect(console.warn).toBeCalledWith('toggling bottomTabs visibility is deprecated on iOS. For more information see https://github.com/wix/react-native-navigation/issues/6416', {
+      bottomTabs: {
+        visible: false
+      }
+    });
+  });
+  describe('searchBar', () => {
+    describe('Android', () => {
+      beforeEach(() => {
+        Platform.OS = 'android';
+      });
+      it('transform searchBar bool to object', () => {
+        const options = {
+          topBar: {
+            searchBar: true
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options.topBar.searchBar).toStrictEqual({
+          visible: true,
+          hideOnScroll: false,
+          hideTopBarOnFocus: false,
+          obscuresBackgroundDuringPresentation: false,
+          backgroundColor: undefined,
+          tintColor: undefined,
+          placeholder: ''
+        });
+      });
+      it('transform searchBar bool to object and merges in deprecated values', () => {
+        const options = {
+          topBar: {
+            searchBar: true,
+            searchBarHiddenWhenScrolling: true,
+            hideNavBarOnFocusSearchBar: true,
+            searchBarBackgroundColor: 'red',
+            searchBarTintColor: 'green',
+            searchBarPlaceholder: 'foo'
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options.topBar.searchBar).toStrictEqual({
+          visible: true,
+          hideOnScroll: true,
+          hideTopBarOnFocus: true,
+          obscuresBackgroundDuringPresentation: false,
+          backgroundColor: {
+            dark: 0xffff0000,
+            light: 0xffff0000
+          },
+          tintColor: {
+            dark: 0xff00ff00,
+            light: 0xff00ff00
+          },
+          placeholder: 'foo'
+        });
+      });
+    });
+    describe('iOS', () => {
+      beforeEach(() => {
+        Platform.OS = 'ios';
+      });
+      it('transform searchBar bool to object', () => {
+        const options = {
+          topBar: {
+            searchBar: true
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options.topBar.searchBar).toStrictEqual({
+          visible: true,
+          hideOnScroll: false,
+          hideTopBarOnFocus: false,
+          obscuresBackgroundDuringPresentation: false,
+          backgroundColor: undefined,
+          tintColor: undefined,
+          placeholder: ''
+        });
+      });
+      it('transform searchBar bool to object and merges in deprecated values', () => {
+        const options = {
+          topBar: {
+            searchBar: true,
+            searchBarHiddenWhenScrolling: true,
+            hideNavBarOnFocusSearchBar: true,
+            searchBarBackgroundColor: 'red',
+            searchBarTintColor: 'green',
+            searchBarPlaceholder: 'foo'
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options.topBar.searchBar).toStrictEqual({
+          visible: true,
+          hideOnScroll: true,
+          hideTopBarOnFocus: true,
+          obscuresBackgroundDuringPresentation: false,
+          backgroundColor: 0xffff0000,
+          tintColor: 0xff00ff00,
+          placeholder: 'foo'
+        });
+      });
+    });
+  });
+  describe('process animations options', () => {
+    const performOnViewsInvolvedInStackAnimation = action => ['content', 'topBar', 'bottomTabs'].forEach(action);
+    describe('push', () => {
+      it('old *.push api is converted into push.*.enter', () => {
+        performOnViewsInvolvedInStackAnimation(view => {
+          const options = {
+            animations: {
+              push: {
+                [view]: {
+                  alpha: {
+                    from: 0,
+                    to: 1
+                  }
+                }
+              }
+            }
+          };
+          uut.processOptions(CommandName.SetRoot, options);
+          expect(options.animations.push).toStrictEqual({
+            [view]: {
+              enter: {
+                alpha: {
+                  from: 0,
+                  to: 1
+                }
+              }
+            }
+          });
+        });
+      });
+      it('StackAnimationOptions based push api is left as is', () => {
+        performOnViewsInvolvedInStackAnimation(view => {
+          const options = {
+            animations: {
+              push: {
+                [view]: {
+                  exit: {
+                    alpha: {
+                      from: 1,
+                      to: 0
+                    }
+                  },
+                  enter: {
+                    alpha: {
+                      from: 0,
+                      to: 1
+                    }
+                  }
+                }
+              }
+            }
+          };
+          uut.processOptions(CommandName.SetRoot, options);
+          expect(options.animations.push).toStrictEqual({
+            [view]: {
+              exit: {
+                alpha: {
+                  from: 1,
+                  to: 0
+                }
+              },
+              enter: {
+                alpha: {
+                  from: 0,
+                  to: 1
+                }
+              }
+            }
+          });
+        });
+      });
+      it('Options not related to views are left as is', () => {
+        performOnViewsInvolvedInStackAnimation(() => {
+          const options = {
+            animations: {
+              push: {
+                enabled: false,
+                waitForRender: true,
+                sharedElementTransitions: [],
+                elementTransitions: []
+              }
+            }
+          };
+          uut.processOptions(CommandName.SetRoot, options);
+          expect(options.animations.push).toStrictEqual({
+            enabled: false,
+            waitForRender: true,
+            sharedElementTransitions: [],
+            elementTransitions: []
+          });
+        });
+      });
+    });
+    describe('pop', () => {
+      it('old pop.content api is converted into pop.content.exit', () => {
+        performOnViewsInvolvedInStackAnimation(view => {
+          const options = {
+            animations: {
+              pop: {
+                [view]: {
+                  alpha: {
+                    from: 0,
+                    to: 1
+                  }
+                }
+              }
+            }
+          };
+          uut.processOptions(CommandName.SetRoot, options);
+          expect(options.animations.pop).toStrictEqual({
+            [view]: {
+              exit: {
+                alpha: {
+                  from: 0,
+                  to: 1
+                }
+              }
+            }
+          });
+        });
+      });
+      it('StackAnimationOptions based pop api is left as is', () => {
+        performOnViewsInvolvedInStackAnimation(view => {
+          const options = {
+            animations: {
+              pop: {
+                [view]: {
+                  exit: {
+                    alpha: {
+                      from: 1,
+                      to: 0
+                    }
+                  },
+                  enter: {
+                    alpha: {
+                      from: 0,
+                      to: 1
+                    }
+                  }
+                }
+              }
+            }
+          };
+          uut.processOptions(CommandName.SetRoot, options);
+          expect(options.animations.pop).toStrictEqual({
+            [view]: {
+              exit: {
+                alpha: {
+                  from: 1,
+                  to: 0
+                }
+              },
+              enter: {
+                alpha: {
+                  from: 0,
+                  to: 1
+                }
+              }
+            }
+          });
+        });
+      });
+      it('Options not related to views are left as is', () => {
+        performOnViewsInvolvedInStackAnimation(() => {
+          const options = {
+            animations: {
+              pop: {
+                enabled: false,
+                waitForRender: true,
+                sharedElementTransitions: [],
+                elementTransitions: []
+              }
+            }
+          };
+          uut.processOptions(CommandName.SetRoot, options);
+          expect(options.animations.pop).toStrictEqual({
+            enabled: false,
+            waitForRender: true,
+            sharedElementTransitions: [],
+            elementTransitions: []
+          });
+        });
+      });
+    });
+    describe('setStackRoot', () => {
+      it('ViewAnimationOptions based setStackRoot api is converted to StackAnimationOptions based api', () => {
+        const options = {
+          animations: {
+            setStackRoot: {
+              alpha: {
+                from: 0,
+                to: 1
+              }
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options.animations.setStackRoot).toStrictEqual({
+          content: {
+            enter: {
+              alpha: {
+                from: 0,
+                to: 1
+              }
+            }
+          }
+        });
+      });
+      it('Disabled ViewAnimationOptions based setStackRoot api is converted to StackAnimationOptions based api', () => {
+        const options = {
+          animations: {
+            setStackRoot: {
+              enabled: false,
+              waitForRender: true
+            }
+          }
+        };
+        uut.processOptions(CommandName.SetRoot, options);
+        expect(options.animations.setStackRoot).toStrictEqual({
+          enabled: false,
+          waitForRender: true,
+          content: {
+            enter: {
+              enabled: false,
+              waitForRender: true
+            }
+          }
+        });
+      });
+      it('StackAnimationOptions based setStackRoot api is left as is', () => {
+        performOnViewsInvolvedInStackAnimation(view => {
+          const options = {
+            animations: {
+              setStackRoot: {
+                [view]: {
+                  enter: {
+                    alpha: {
+                      from: 0,
+                      to: 1
+                    }
+                  }
+                }
+              }
+            }
+          };
+          uut.processOptions(CommandName.SetRoot, options);
+          expect(options.animations.setStackRoot).toStrictEqual({
+            [view]: {
+              enter: {
+                alpha: {
+                  from: 0,
+                  to: 1
+                }
+              }
+            }
+          });
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=OptionsProcessor.test.js.map