From 9308994db23b3d1acf903f94f12e0b2eabe84807 Mon Sep 17 00:00:00 2001 From: Aleck Greenham Date: Sun, 23 Apr 2017 20:22:19 +0100 Subject: [PATCH] [tests] Move test suite into same repo --- .npmignore | 1 + README.md | 2 +- tests/.babelrc | 9 + tests/.buckconfig | 6 + tests/.editorconfig | 10 + tests/.eslintrc | 40 + tests/.flowconfig | 47 + tests/.gitattributes | 1 + tests/.gitignore | 61 + tests/.watchmanconfig | 1 + tests/README.md | 363 ++++ .../src/hooks/asynchronousHooksTests.js | 287 +++ tests/__tests__/src/hooks/failingHookTests.js | 661 +++++++ tests/__tests__/src/hooks/hookScopeTests.js | 278 +++ .../src/hooks/hooksCallOrderTests.js | 310 ++++ tests/__tests__/src/hooks/index.js | 17 + .../__tests__/src/hooks/timingOutHookTests.js | 327 ++++ tests/__tests__/src/index.js | 75 + .../src/tests/asynchronousTestTests.js | 82 + tests/__tests__/src/tests/failingTestTests.js | 146 ++ tests/__tests__/src/tests/focusedTestTests.js | 84 + tests/__tests__/src/tests/index.js | 17 + tests/__tests__/src/tests/pendingTestTests.js | 108 ++ tests/__tests__/src/tests/timingOutTests.js | 84 + tests/android/app/BUCK | 66 + tests/android/app/build.gradle | 144 ++ tests/android/app/google-services.json | 42 + tests/android/app/proguard-rules.pro | 66 + .../android/app/src/main/AndroidManifest.xml | 51 + .../app/src/main/assets/fonts/Entypo.ttf | Bin 0 -> 65584 bytes .../app/src/main/assets/fonts/EvilIcons.ttf | Bin 0 -> 13128 bytes .../app/src/main/assets/fonts/FontAwesome.ttf | Bin 0 -> 165548 bytes .../app/src/main/assets/fonts/Foundation.ttf | Bin 0 -> 56976 bytes .../app/src/main/assets/fonts/Ionicons.ttf | Bin 0 -> 143936 bytes .../assets/fonts/MaterialCommunityIcons.ttf | Bin 0 -> 245676 bytes .../src/main/assets/fonts/MaterialIcons.ttf | Bin 0 -> 128180 bytes .../app/src/main/assets/fonts/Octicons.ttf | Bin 0 -> 27428 bytes .../src/main/assets/fonts/SimpleLineIcons.ttf | Bin 0 -> 54056 bytes .../app/src/main/assets/fonts/Zocial.ttf | Bin 0 -> 25552 bytes .../reactnativefirebasedemo/MainActivity.java | 15 + .../MainApplication.java | 44 + .../main/res/drawable-hdpi/ic_launcher.png | Bin 0 -> 5271 bytes .../main/res/drawable-mdpi/ic_launcher.png | Bin 0 -> 3055 bytes .../main/res/drawable-xhdpi/ic_launcher.png | Bin 0 -> 7309 bytes .../main/res/drawable-xxhdpi/ic_launcher.png | Bin 0 -> 11703 bytes .../main/res/drawable-xxxhdpi/ic_launcher.png | Bin 0 -> 16380 bytes .../app/src/main/res/values/strings.xml | 3 + .../app/src/main/res/values/styles.xml | 8 + tests/android/build.gradle | 48 + tests/android/gradle.properties | 20 + tests/android/gradlew | 160 ++ tests/android/gradlew.bat | 90 + tests/android/keystores/BUCK | 8 + .../keystores/debug.keystore.properties | 4 + tests/android/settings.gradle | 7 + .../assets/test-suite-screenshot-android.png | Bin 0 -> 21824 bytes tests/index.android.js | 5 + tests/index.ios.js | 4 + tests/ios/GoogleService-Info.plist | 40 + .../ReactNativeFirebaseDemo-tvOS/Info.plist | 54 + .../Info.plist | 24 + .../project.pbxproj | 1537 +++++++++++++++++ .../ReactNativeFirebaseDemo-tvOS.xcscheme | 129 ++ .../ReactNativeFirebaseDemo.xcscheme | 129 ++ .../ios/ReactNativeFirebaseDemo/AppDelegate.h | 16 + .../ios/ReactNativeFirebaseDemo/AppDelegate.m | 39 + .../Base.lproj/LaunchScreen.xib | 42 + .../AppIcon.appiconset/Contents.json | 74 + .../AppIcon.appiconset/Icon-20@2x.png | Bin 0 -> 3185 bytes .../AppIcon.appiconset/Icon-20@3x.png | Bin 0 -> 5367 bytes .../AppIcon.appiconset/Icon-29.png | Bin 0 -> 2051 bytes .../AppIcon.appiconset/Icon-29@2x.png | Bin 0 -> 5041 bytes .../AppIcon.appiconset/Icon-29@3x.png | Bin 0 -> 8549 bytes .../AppIcon.appiconset/Icon-40@2x.png | Bin 0 -> 7728 bytes .../AppIcon.appiconset/Icon-40@3x.png | Bin 0 -> 12477 bytes .../AppIcon.appiconset/Icon-57.png | Bin 0 -> 5072 bytes .../AppIcon.appiconset/Icon-57@2x.png | Bin 0 -> 11757 bytes .../AppIcon.appiconset/Icon-60@2x.png | Bin 0 -> 12477 bytes .../AppIcon.appiconset/Icon-60@3x.png | Bin 0 -> 20521 bytes .../Images.xcassets/Contents.json | 6 + tests/ios/ReactNativeFirebaseDemo/Info.plist | 66 + tests/ios/ReactNativeFirebaseDemo/main.m | 18 + .../ReactNativeFirebaseDemoTests/Info.plist | 24 + .../ReactNativeFirebaseDemoTests.m | 70 + tests/lib/RunStatus.js | 5 + tests/lib/TestDSL.js | 251 +++ tests/lib/TestRun.js | 386 +++++ tests/lib/TestSuite.js | 148 ++ tests/lib/TestSuiteDefinition.js | 360 ++++ tests/package.json | 70 + tests/src/actions/AppActions.js | 17 + tests/src/actions/FCMActions.js | 8 + tests/src/actions/TestActions.js | 26 + tests/src/components/Banner.js | 51 + tests/src/components/Icon.js | 75 + tests/src/components/OverviewControlButton.js | 70 + tests/src/components/StatusIndicator.js | 52 + tests/src/components/TestControlButton.js | 71 + .../src/components/TestSuiteControlButton.js | 96 + tests/src/containers/CoreContainer.js | 82 + tests/src/firebase.js | 32 + tests/src/helpers.js | 3 + tests/src/main.js | 64 + tests/src/navigator.js | 20 + tests/src/reducers/device.js | 35 + tests/src/reducers/focusedTestIdsReducers.js | 9 + tests/src/reducers/index.js | 17 + tests/src/reducers/pendingTestIdsReducers.js | 9 + tests/src/reducers/testContextsReducers.js | 9 + tests/src/reducers/testSuitesReducers.js | 23 + tests/src/reducers/testsReducers.js | 22 + tests/src/screens/Overview.js | 299 ++++ tests/src/screens/Suite.js | 404 +++++ tests/src/screens/Test.js | 149 ++ tests/src/store/setup.js | 43 + tests/src/store/whitelist.js | 1 + tests/src/tests/analytics/analytics.js | 64 + tests/src/tests/analytics/index.js | 9 + tests/src/tests/auth/authTests.js | 311 ++++ tests/src/tests/auth/index.js | 10 + tests/src/tests/crash/index.js | 10 + tests/src/tests/crash/log.js | 17 + tests/src/tests/database/index.js | 21 + tests/src/tests/database/ref/childTests.js | 69 + tests/src/tests/database/ref/factoryTests.js | 38 + tests/src/tests/database/ref/index.js | 43 + tests/src/tests/database/ref/isEqualTests.js | 41 + tests/src/tests/database/ref/keyTests.js | 30 + tests/src/tests/database/ref/offTests.js | 276 +++ tests/src/tests/database/ref/onTests.js | 125 ++ tests/src/tests/database/ref/onceTests.js | 81 + tests/src/tests/database/ref/parentTests.js | 33 + tests/src/tests/database/ref/pushTests.js | 113 ++ tests/src/tests/database/ref/queryTests.js | 25 + tests/src/tests/database/ref/refTests.js | 15 + tests/src/tests/database/ref/removeTests.js | 44 + tests/src/tests/database/ref/rootTests.js | 36 + tests/src/tests/database/ref/setTests.js | 73 + .../tests/database/ref/transactionTests.js | 53 + tests/src/tests/database/ref/updateTests.js | 112 ++ tests/src/tests/database/snapshot.js | 116 ++ tests/src/tests/index.js | 216 +++ tests/src/tests/messaging/index.js | 10 + tests/src/tests/messaging/messagingTests.js | 149 ++ tests/src/tests/storage/index.js | 10 + tests/src/tests/storage/storageTests.js | 90 + tests/src/tests/support/DatabaseContents.js | 25 + tests/src/tests/support/databaseTypeMap.js | 10 + 148 files changed, 11251 insertions(+), 1 deletion(-) create mode 100644 tests/.babelrc create mode 100644 tests/.buckconfig create mode 100644 tests/.editorconfig create mode 100644 tests/.eslintrc create mode 100644 tests/.flowconfig create mode 100644 tests/.gitattributes create mode 100644 tests/.gitignore create mode 100644 tests/.watchmanconfig create mode 100644 tests/README.md create mode 100644 tests/__tests__/src/hooks/asynchronousHooksTests.js create mode 100644 tests/__tests__/src/hooks/failingHookTests.js create mode 100644 tests/__tests__/src/hooks/hookScopeTests.js create mode 100644 tests/__tests__/src/hooks/hooksCallOrderTests.js create mode 100644 tests/__tests__/src/hooks/index.js create mode 100644 tests/__tests__/src/hooks/timingOutHookTests.js create mode 100644 tests/__tests__/src/index.js create mode 100644 tests/__tests__/src/tests/asynchronousTestTests.js create mode 100644 tests/__tests__/src/tests/failingTestTests.js create mode 100644 tests/__tests__/src/tests/focusedTestTests.js create mode 100644 tests/__tests__/src/tests/index.js create mode 100644 tests/__tests__/src/tests/pendingTestTests.js create mode 100644 tests/__tests__/src/tests/timingOutTests.js create mode 100644 tests/android/app/BUCK create mode 100644 tests/android/app/build.gradle create mode 100644 tests/android/app/google-services.json create mode 100644 tests/android/app/proguard-rules.pro create mode 100644 tests/android/app/src/main/AndroidManifest.xml create mode 100644 tests/android/app/src/main/assets/fonts/Entypo.ttf create mode 100644 tests/android/app/src/main/assets/fonts/EvilIcons.ttf create mode 100644 tests/android/app/src/main/assets/fonts/FontAwesome.ttf create mode 100644 tests/android/app/src/main/assets/fonts/Foundation.ttf create mode 100644 tests/android/app/src/main/assets/fonts/Ionicons.ttf create mode 100644 tests/android/app/src/main/assets/fonts/MaterialCommunityIcons.ttf create mode 100644 tests/android/app/src/main/assets/fonts/MaterialIcons.ttf create mode 100644 tests/android/app/src/main/assets/fonts/Octicons.ttf create mode 100644 tests/android/app/src/main/assets/fonts/SimpleLineIcons.ttf create mode 100644 tests/android/app/src/main/assets/fonts/Zocial.ttf create mode 100644 tests/android/app/src/main/java/com/reactnativefirebasedemo/MainActivity.java create mode 100644 tests/android/app/src/main/java/com/reactnativefirebasedemo/MainApplication.java create mode 100755 tests/android/app/src/main/res/drawable-hdpi/ic_launcher.png create mode 100755 tests/android/app/src/main/res/drawable-mdpi/ic_launcher.png create mode 100755 tests/android/app/src/main/res/drawable-xhdpi/ic_launcher.png create mode 100755 tests/android/app/src/main/res/drawable-xxhdpi/ic_launcher.png create mode 100755 tests/android/app/src/main/res/drawable-xxxhdpi/ic_launcher.png create mode 100644 tests/android/app/src/main/res/values/strings.xml create mode 100644 tests/android/app/src/main/res/values/styles.xml create mode 100644 tests/android/build.gradle create mode 100644 tests/android/gradle.properties create mode 100755 tests/android/gradlew create mode 100644 tests/android/gradlew.bat create mode 100644 tests/android/keystores/BUCK create mode 100644 tests/android/keystores/debug.keystore.properties create mode 100644 tests/android/settings.gradle create mode 100644 tests/docs/assets/test-suite-screenshot-android.png create mode 100644 tests/index.android.js create mode 100644 tests/index.ios.js create mode 100644 tests/ios/GoogleService-Info.plist create mode 100644 tests/ios/ReactNativeFirebaseDemo-tvOS/Info.plist create mode 100644 tests/ios/ReactNativeFirebaseDemo-tvOSTests/Info.plist create mode 100644 tests/ios/ReactNativeFirebaseDemo.xcodeproj/project.pbxproj create mode 100644 tests/ios/ReactNativeFirebaseDemo.xcodeproj/xcshareddata/xcschemes/ReactNativeFirebaseDemo-tvOS.xcscheme create mode 100644 tests/ios/ReactNativeFirebaseDemo.xcodeproj/xcshareddata/xcschemes/ReactNativeFirebaseDemo.xcscheme create mode 100644 tests/ios/ReactNativeFirebaseDemo/AppDelegate.h create mode 100644 tests/ios/ReactNativeFirebaseDemo/AppDelegate.m create mode 100644 tests/ios/ReactNativeFirebaseDemo/Base.lproj/LaunchScreen.xib create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Contents.json create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-20@2x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-20@3x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-29.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-29@2x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-29@3x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-40@2x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-40@3x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-57.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-57@2x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-60@2x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-60@3x.png create mode 100644 tests/ios/ReactNativeFirebaseDemo/Images.xcassets/Contents.json create mode 100644 tests/ios/ReactNativeFirebaseDemo/Info.plist create mode 100644 tests/ios/ReactNativeFirebaseDemo/main.m create mode 100644 tests/ios/ReactNativeFirebaseDemoTests/Info.plist create mode 100644 tests/ios/ReactNativeFirebaseDemoTests/ReactNativeFirebaseDemoTests.m create mode 100644 tests/lib/RunStatus.js create mode 100644 tests/lib/TestDSL.js create mode 100644 tests/lib/TestRun.js create mode 100644 tests/lib/TestSuite.js create mode 100644 tests/lib/TestSuiteDefinition.js create mode 100644 tests/package.json create mode 100644 tests/src/actions/AppActions.js create mode 100644 tests/src/actions/FCMActions.js create mode 100644 tests/src/actions/TestActions.js create mode 100644 tests/src/components/Banner.js create mode 100644 tests/src/components/Icon.js create mode 100644 tests/src/components/OverviewControlButton.js create mode 100644 tests/src/components/StatusIndicator.js create mode 100644 tests/src/components/TestControlButton.js create mode 100644 tests/src/components/TestSuiteControlButton.js create mode 100644 tests/src/containers/CoreContainer.js create mode 100644 tests/src/firebase.js create mode 100644 tests/src/helpers.js create mode 100644 tests/src/main.js create mode 100644 tests/src/navigator.js create mode 100644 tests/src/reducers/device.js create mode 100644 tests/src/reducers/focusedTestIdsReducers.js create mode 100644 tests/src/reducers/index.js create mode 100644 tests/src/reducers/pendingTestIdsReducers.js create mode 100644 tests/src/reducers/testContextsReducers.js create mode 100644 tests/src/reducers/testSuitesReducers.js create mode 100644 tests/src/reducers/testsReducers.js create mode 100644 tests/src/screens/Overview.js create mode 100644 tests/src/screens/Suite.js create mode 100644 tests/src/screens/Test.js create mode 100644 tests/src/store/setup.js create mode 100644 tests/src/store/whitelist.js create mode 100644 tests/src/tests/analytics/analytics.js create mode 100644 tests/src/tests/analytics/index.js create mode 100644 tests/src/tests/auth/authTests.js create mode 100644 tests/src/tests/auth/index.js create mode 100644 tests/src/tests/crash/index.js create mode 100644 tests/src/tests/crash/log.js create mode 100644 tests/src/tests/database/index.js create mode 100644 tests/src/tests/database/ref/childTests.js create mode 100644 tests/src/tests/database/ref/factoryTests.js create mode 100644 tests/src/tests/database/ref/index.js create mode 100644 tests/src/tests/database/ref/isEqualTests.js create mode 100644 tests/src/tests/database/ref/keyTests.js create mode 100644 tests/src/tests/database/ref/offTests.js create mode 100644 tests/src/tests/database/ref/onTests.js create mode 100644 tests/src/tests/database/ref/onceTests.js create mode 100644 tests/src/tests/database/ref/parentTests.js create mode 100644 tests/src/tests/database/ref/pushTests.js create mode 100644 tests/src/tests/database/ref/queryTests.js create mode 100644 tests/src/tests/database/ref/refTests.js create mode 100644 tests/src/tests/database/ref/removeTests.js create mode 100644 tests/src/tests/database/ref/rootTests.js create mode 100644 tests/src/tests/database/ref/setTests.js create mode 100644 tests/src/tests/database/ref/transactionTests.js create mode 100644 tests/src/tests/database/ref/updateTests.js create mode 100644 tests/src/tests/database/snapshot.js create mode 100644 tests/src/tests/index.js create mode 100644 tests/src/tests/messaging/index.js create mode 100644 tests/src/tests/messaging/messagingTests.js create mode 100644 tests/src/tests/storage/index.js create mode 100644 tests/src/tests/storage/storageTests.js create mode 100644 tests/src/tests/support/DatabaseContents.js create mode 100644 tests/src/tests/support/databaseTypeMap.js diff --git a/.npmignore b/.npmignore index 8d5f96d6..dc0208e2 100644 --- a/.npmignore +++ b/.npmignore @@ -60,3 +60,4 @@ docs .idea coverage yarn.lock +tests diff --git a/README.md b/README.md index 94c7e3bf..e04793aa 100644 --- a/README.md +++ b/README.md @@ -32,7 +32,7 @@ The native SDKs also allow us to hook into device sdk's which are not possible w ### Test app -To help ensure changes and features work across both iOS & Android, we've developed an app specifically to test `react-native-firebase` against the [`firebase` web SDK](https://www.npmjs.com/package/firebase). Please see the [`react-native-firebase-tests`](https://github.com/invertase/react-native-firebase-tests) repository for more information. +To help ensure changes and features work across both iOS & Android, we've developed an app specifically to test `react-native-firebase` against the [`firebase` web SDK](https://www.npmjs.com/package/firebase). Please see the [`tests`](tests/README.md) directory for more information.
diff --git a/tests/.babelrc b/tests/.babelrc new file mode 100644 index 00000000..71d5ed66 --- /dev/null +++ b/tests/.babelrc @@ -0,0 +1,9 @@ +{ + "presets": [ + "react-native" + ], + "ignore": [ + "node_modules/diff/lib/**/*.js", + "node_modules/diff/node_modules/**/*.js" + ] +} diff --git a/tests/.buckconfig b/tests/.buckconfig new file mode 100644 index 00000000..934256cb --- /dev/null +++ b/tests/.buckconfig @@ -0,0 +1,6 @@ + +[android] + target = Google Inc.:Google APIs:23 + +[maven_repositories] + central = https://repo1.maven.org/maven2 diff --git a/tests/.editorconfig b/tests/.editorconfig new file mode 100644 index 00000000..0f099897 --- /dev/null +++ b/tests/.editorconfig @@ -0,0 +1,10 @@ +# editorconfig.org +root = true + +[*] +indent_style = space +indent_size = 2 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true diff --git a/tests/.eslintrc b/tests/.eslintrc new file mode 100644 index 00000000..c9d71b91 --- /dev/null +++ b/tests/.eslintrc @@ -0,0 +1,40 @@ +{ + "extends": "airbnb", + "parser": "babel-eslint", + "ecmaFeatures": { + "jsx": true + }, + "plugins": [ + "flowtype" + ], + "env": { + "es6": true, + "jasmine": true + }, + "parserOptions": { + "ecmaFeatures": { + "experimentalObjectRestSpread": true + } + }, + "rules": { + "class-methods-use-this": 0, + "no-underscore-dangle": 0, + "no-use-before-define": 0, + "arrow-body-style": 0, + "import/prefer-default-export": 0, + "radix": 0, + "new-cap": 0, + "max-len": 0, + "no-continue": 0, + "no-console": 0, + "global-require": 0, + "import/extensions": 0, + "import/no-unresolved": 0, + "import/no-extraneous-dependencies": 0, + "react/jsx-filename-extension": 0 + }, + "globals": { + "__DEV__": true, + "window": true + } +} diff --git a/tests/.flowconfig b/tests/.flowconfig new file mode 100644 index 00000000..53b071ef --- /dev/null +++ b/tests/.flowconfig @@ -0,0 +1,47 @@ +[ignore] +; We fork some components by platform +.*/*[.]android.js + +; Ignore "BUCK" generated dirs +/\.buckd/ + +; Ignore unexpected extra "@providesModule" +.*/node_modules/.*/node_modules/fbjs/.* + +; Ignore duplicate module providers +; For RN Apps installed via npm, "Libraries" folder is inside +; "node_modules/react-native" but in the source repo it is in the root +.*/Libraries/react-native/React.js +.*/Libraries/react-native/ReactNative.js + +[include] + +[libs] +node_modules/react-native/Libraries/react-native/react-native-interface.js +node_modules/react-native/flow +flow/ + +[options] +emoji=true + +module.system=haste + +experimental.strict_type_args=true + +munge_underscores=true + +module.name_mapper='^~\/\(.*\)$' -> '/\1' + + +suppress_type=$FlowIssue +suppress_type=$FlowFixMe +suppress_type=$FixMe + +suppress_comment=\\(.\\|\n\\)*\\$FlowFixMe\\($\\|[^(]\\|(\\(>=0\\.\\(3[0-8]\\|[1-2][0-9]\\|[0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\) +suppress_comment=\\(.\\|\n\\)*\\$FlowIssue\\((\\(>=0\\.\\(3[0-8]\\|1[0-9]\\|[1-2][0-9]\\).[0-9]\\)? *\\(site=[a-z,_]*react_native[a-z,_]*\\)?)\\)?:? #[0-9]+ +suppress_comment=\\(.\\|\n\\)*\\$FlowFixedInNextDeploy + +unsafe.enable_getters_and_setters=true + +[version] +^0.38.0 diff --git a/tests/.gitattributes b/tests/.gitattributes new file mode 100644 index 00000000..d42ff183 --- /dev/null +++ b/tests/.gitattributes @@ -0,0 +1 @@ +*.pbxproj -text diff --git a/tests/.gitignore b/tests/.gitignore new file mode 100644 index 00000000..6e4a1e09 --- /dev/null +++ b/tests/.gitignore @@ -0,0 +1,61 @@ +# OSX +# +.DS_Store + +# Xcode +# +build/ +*.pbxuser +!default.pbxuser +*.mode1v3 +!default.mode1v3 +*.mode2v3 +!default.mode2v3 +*.perspectivev3 +!default.perspectivev3 +xcuserdata +*.xccheckout +*.moved-aside +DerivedData +*.hmap +*.ipa +*.xcuserstate +project.xcworkspace + +# Android/IntelliJ +# + +android/gradle +.idea +.gradle +local.properties +*.iml + +# node.js +# +node_modules/ +ios/Pods +npm-debug.log +yarn-error.log +yarn.lock +npm-debug* + +# BUCK +buck-out/ +\.buckd/ +*.keystore + +# fastlane +# +# It is recommended to not store the screenshots in the git repo. Instead, use fastlane to re-generate the +# screenshots whenever they are needed. +# For more information about the recommended setup visit: +# https://github.com/fastlane/fastlane/blob/master/fastlane/docs/Gitignore.md + +fastlane/report.xml +fastlane/Preview.html +fastlane/screenshots +ios/Podfile +ios/Podfile.lock +ios/Pods/ +ios/ReactNativeFirebaseDemo.xcworkspace/ diff --git a/tests/.watchmanconfig b/tests/.watchmanconfig new file mode 100644 index 00000000..9e26dfee --- /dev/null +++ b/tests/.watchmanconfig @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/tests/README.md b/tests/README.md new file mode 100644 index 00000000..1ff84a01 --- /dev/null +++ b/tests/README.md @@ -0,0 +1,363 @@ +# react-native-firebase test suite + +An **iOS** and **Android** React Native app built to test [`react-native-firebase`](https://github.com/invertase/react-native-firebase). + +## Install + +1. Clone the test application + +```bash +git clone https://github.com/invertase/react-native-firebase.git +``` + +2. Install the dependencies listed in `package.json` + +```bash +cd react-native-firebase/tests/ && npm install +``` + +### iOS Installation + +3. Install the test application's CocoaPods. +* See [troubleshooting](#installing-podfiles) if this doesn't work for you. + +```bash +npm run ios:pod:install +``` + +4. Start the React Native packager + +```bash +npm run start +``` + +5. In another terminal window, install the app on your emulator: + +```bash +npm run ios:dev +``` + +### Android Installation + +6. Start your emulator through Android Studio: Tools > Android > AVD Manager + +> You will need a version of the Android emulator that has the Play Store installed (you should be able to find it on the emulator's home screen or on the list of apps). + +7. Start the React Native packager if you haven't already in the iOS instructions. + +```bash +npm run start +``` + +8. Run the test app on your Android emulator: + +```bash +npm run android:dev +``` + +## Documentation + +`react-native-firebase` aims to match the Firebase Web API wherever possible. As a result, the tests are largely derived from the [Firebase Web API documentation](https://firebase.google.com/docs/reference/js/). + + +## Tests + +Tests are bootstrapped and ran when the app is booted. The status of each test suite and individual test will update as and when a test has completed or errored. + +### Running tests + +Tests can be run by pressing the play button in the toolbar of the app. Test can be run individually, by suite, or all at once. + +![Test suite Android](/docs/assets/test-suite-screenshot-android.png?raw=true) + + +### Adding test + +To add tests to an existing test suite, you need to pass a function to `addTests`. + +#### Synchronous tests + +Synchronous tests are created by passing a function to `it`. The next test is run immediately after the last line is executed. + +```javascript +testSuite.addTests(({ describe, it }) => { + describe('synchronous test', () => { + + it('does something correctly', () => { + + }); + + }); +}); +``` + +#### Asynchronous tests + +Tests can be asynchronous if they return a promise. The test suite waits for the promise to resolve before executing the next test. + +```javascript +testSuite.addTests(({ describe, it }) => { + describe('async successful test', () => { + + it('does something correctly', () => { + return new Promise((resolve, reject) => { + // ... + resolve(); + }); + }); + + }); +}); +``` + +Asynchronous tests can also be created using the `async` function syntax: + +```javascript +testSuite.addTests(({ describe, it }) => { + describe('async successful test', () => { + + it('does something correctly', async () => { + // ... + + await somethingAsynchronous(); + }); + + }); +}); +``` + +> When rejecting, always ensure a valid [JavaScript Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) is provided. + +### Creating a new test suite + +A test suite groups together test categories under the same Firebase feature. e.g. *Realtime Database* tests. + +To add a new test suite: + +1. Create a new directory within `src/tests`. +2. Create an `index.js` file. + +In this file, you need to create an instance of `TestSuite` - see [TestSuite constructor](#testsuite-constructor). + +```javascript +import TestSuite from 'lib/TestSuite'; + +const MyNewSuite = new TestSuite('Realtime Database Storage', 'Upload/Download storage tests'); + +export default MyNewSuite; +``` + +3. `addTests` is then used as many times as is necessary to add tests to the test suite, accepting a function that defines one or more tests. +4. The test suite must then be imported into `src/tests/index.js` and added to `testSuiteInstances` in order for it to be included in the list of test suites available to run in the app. + +## TestSuite API + +### TestSuite Constructor + +The TestSuite constructor accepts 3 arguments: + +- **name**: String containing the name of the test suite. e.g. 'Realtime Storage' +- **description**: String containing description of the test suite +- **firebase**: This is the object exported from `src/firebase` and contains both the native and web firebase instances. + +```javascript +import firebase from '../firebase'; + +new TestSuite('Realtime Database Storage', 'firebase.database()', firebase); +``` + +### Test Definition + +#### describe() + +The `describe()` function takes 2 - 3 arguments: + +- **description**: String describing the context or target of all the tests defined in `testDefinitions` +- **options**: (Optional) object of options: + * **focus**: Boolean marking all the tests defined in `testDefinitions` (and any others marked as focused) as the only one(s) that should run + * **pending**: Boolean marking all the tests defined in `testDefinitions` as excluded from running in the test suite +- **testDefinitions**: Function that defines 1 or more tests by calling `it`, `xit` or `fit` + +```javascript +function testCategory({ describe }) { + + describe('a feature', () => { + it('does something synchronously', () => { + + }); + + }); +} + +export default testCategory; +``` + +`describe()` statements can be arbitrarily nested. + +#### context() + +`context()` is an alias for `describe()` provided as syntactical sugar. `xcontext()` and `fcontext()` work similar to `xdescribe()` and `fdescribe()`, respectively. + +#### it() + +The `it()` function takes 2 - 3 arguments: + +- **description**: String describing the test defined in `testDefinition` +- **options**: (Optional) object of options: + * **focus**: Boolean marking the test defined in `testDefinition` (and any others marked as focused) as the only one(s) that should run + * **pending**: Boolean marking the test defined in `testDefinition` as excluded from running in the test suite + * **timeout**: Time in milliseconds a test is allowed to execute before it's considered to have timed out. Default is 5000ms (5 seconds). +- **testDefinition**: Function that defines a test with one or more assertions. Can be a synchronous or asynchronous function. Functions that return a promise cause the test environment to wait for the promise to be resolved before proceding to the next test. + +```javascript +it('does something synchronously', () => { + +}); + +it('does something asynchronously', async () => { + +}); + +it('does something else asynchronously', () => { + return new Promise(/* ... */); +}); +``` + +`it()` statements can *not* be nested. + +#### xdescribe() & xit() + +##### Pending Tests + +You can mark all tests within a `describe` statement as pending by using the `xdescribe` function instead. The test will appear greyed out and will not be run as part of the test suite. + +You can mark a single test as pending by using `xit` as you would `it`. + +Tests should only be marked as pending temporarily, and should not normally be committed to the test suite unless they are fully implemented. + +#### fdescribe() & fit() + +##### Focused Tests + +You can mark all tests within a `describe` statement as focused by using the `fdescribe` function instead. Tests that are focused will be the only ones that appear and run in the test suite until all tests are removed from being focused. This is useful for running and working on a few tests at a time. + +You can mark a single test as focused by using `fit` as you would `it`. + +#### Test Assertions + +The assertion library Should.js is used in the tests. The complete list of available assertions is available in the [Should.js documentation](https://shouldjs.github.io). + +#### Lifecycle methods + +Four lifecycle methods are provided for each test context: + +- **before** - Run once, before the current test context executes +- **beforeEach** - Run before every test in the current test context +- **after** - Run once, after the current test context has finished executing +- **afterEach** - Run after every test in the current test context + +A new test context is created when the test suite encounters any of `describe`, `xdescribe`, `fdescribe`, `context`, `xcontext` or `fcontext`, and close again when it reaches the end of the block. Test contexts can be nested and lifecycle hooks set for parent contexts apply for all descendents. + +Each lifecycle hook accepts either a synchronous function, a function that returns a promise or an `async` function. + +```javascript +function testCategory({ before, beforeEach, afterEach, after }) { + + before(() => console.log('Before all tests start.')); + beforeEach(() => console.log('Before every test starts.')); + + describe('sync successful test', function() { + // ... + }); + + afterEach(() => console.log('After each test starts.')); + after(() => console.log('After all tests are complete, with success or error.')); +} +``` + +An optional hash of options can also be passed as the first argument, defining one or more of the following values: + +* **timeout**: Time in milliseconds a hook is allowed to execute before it's considered to have timed out. Default is 5000ms (5 seconds). + +#### Accessing Firebase + +`react-native-firebase` is available `firebase.native`: + +```javascript +function testCategory({ describe, firebase }) { + + describe('sync successful test', 'category', function() { + firebase.native.database(); + }); +} +``` + +If you need to access the web API for Firebase to compare with the functionality of `react-native-firebase`, you can access it on `firebase.web`. + +> All tests should be written in terms of `react-native-firebase`'s behaviour and should **not** include direct comparisons with the web API. It's available for reference, only. + +## Development + +### Running test suite against latest version of react-native-firebase + +You can use the node module `wml` to automatically copy changes you make to `react-native-firebase` over to the test application so you can run the test suite against them. + +1. Install `wml` globally: + +```bash +npm install wml -g +``` + +2. Configure `wml` to copy changes from `react-native-firebase` to `react-native-firebase/tests/node_modules/react-native-firebase` is: + +```bash +wml add /full/path/to/react-native-firebase /full/path/to/react-native-firebase/tests/node_modules/react-native-firebase +``` + +3. Start `wml`: + +```bash +wml start +``` + +> JavaScript changes require restarting the React Native packager to take effect + +> Java changes will need to be rebuilt in Android Studio + +> Objective-C changes need to be rebuilt in Xcode + +4. Stop `wml` when you are finished: +```bash +wml stop +``` + +### Debugging or viewing internals of the test suite + +`react-native-firebase/tests` is compatible with [react-native-debugger](https://github.com/jhen0409/react-native-debugger) and is the recommended way to view the internal state of the test suite for development or troubleshooting. + +It allows you to view state and prop values of the React component tree, view the actions and contents of the Redux store and view and interact with the debugging console. + +Make sure **Remote JS Debugging** when running the application and close any chrome debugging windows that appear and start React Native Debugger. + +### Running the internal tests + +`react-native-firebase-tests` has its own tests to verify the testing framework is working as expected. These are run from the command line: + +```bash +npm run internal-tests +``` + +## Troubleshooting + +### Invalid React.podspec file: no implicit conversion of nil into String + +This error occurs if you are using ruby version 2.1.2. Upgrade your version of ruby and try again. + + +### Unable to resolve module ../../../node_modules/react-native/packager/... + +Run the packager separately, clearing the cache: + +```bash +npm start -- --reset-cache +``` diff --git a/tests/__tests__/src/hooks/asynchronousHooksTests.js b/tests/__tests__/src/hooks/asynchronousHooksTests.js new file mode 100644 index 00000000..0190eb86 --- /dev/null +++ b/tests/__tests__/src/hooks/asynchronousHooksTests.js @@ -0,0 +1,287 @@ +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function asynchronousHooksTests({ it: _it, describe: _describe }) { + _describe('before hooks:', () => { + _it('can return a promise that is resolved before executing other hooks and tests', async () => { + let valueBySecondHook = null; + let valueByTest = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, before }) => { + let resolved = false; + + before(() => { + return new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + before(() => { + valueBySecondHook = resolved; + }); + + it('', () => { + valueByTest = resolved; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondHook.should.equal(true); + valueByTest.should.equal(true); + }); + + _it('can be an asynchronous function that is awaited before executing other hooks and tests', async () => { + let valueBySecondHook = null; + let valueByTest = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, before }) => { + let resolved = false; + + before(async () => { + await new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + before(() => { + valueBySecondHook = resolved; + }); + + it('', () => { + valueByTest = resolved; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondHook.should.equal(true); + valueByTest.should.equal(true); + }); + }); + + _describe('beforeEach hooks:', () => { + _it('can return a promise that is resolved before executing other hooks and tests', async () => { + let valueBySecondHook = null; + let valueByTest = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, beforeEach }) => { + let resolved = false; + + beforeEach(() => { + return new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + beforeEach(() => { + valueBySecondHook = resolved; + }); + + it('', () => { + valueByTest = resolved; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondHook.should.equal(true); + valueByTest.should.equal(true); + }); + + _it('can be an asynchronous function that is awaited before executing other hooks and tests', async () => { + let valueBySecondHook = null; + let valueByTest = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, beforeEach }) => { + let resolved = false; + + beforeEach(async () => { + await new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + beforeEach(() => { + valueBySecondHook = resolved; + }); + + it('', () => { + valueByTest = resolved; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondHook.should.equal(true); + valueByTest.should.equal(true); + }); + }); + + _describe('afterEach hooks:', () => { + _it('can return a promise that is resolved before executing other hooks and tests', async () => { + let valueBySecondHook = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, afterEach }) => { + let resolved = false; + + afterEach(() => { + return new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + afterEach(() => { + valueBySecondHook = resolved; + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondHook.should.equal(true); + }); + + _it('can be an asynchronous function that is awaited before executing other hooks and tests', async () => { + let valueBySecondHook = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, afterEach }) => { + let resolved = false; + + afterEach(async () => { + await new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + afterEach(() => { + valueBySecondHook = resolved; + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondHook.should.equal(true); + }); + }); + + _describe('after hooks:', () => { + _it('can return a promise that is resolved before executing other hooks and tests', async () => { + let valueBySecondHook = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, after }) => { + let resolved = false; + + after(() => { + return new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + after(() => { + valueBySecondHook = resolved; + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondHook.should.equal(true); + }); + + _it('can be an asynchronous function that is awaited before executing other hooks and tests', async () => { + let valueBySecondHook = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, after }) => { + let resolved = false; + + after(async () => { + await new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + after(() => { + valueBySecondHook = resolved; + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondHook.should.equal(true); + }); + }); +} + +export default asynchronousHooksTests; diff --git a/tests/__tests__/src/hooks/failingHookTests.js b/tests/__tests__/src/hooks/failingHookTests.js new file mode 100644 index 00000000..57f104c7 --- /dev/null +++ b/tests/__tests__/src/hooks/failingHookTests.js @@ -0,0 +1,661 @@ +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function failingHookTests({ it: _it, describe: _describe }) { + _describe('before hooks:', () => { + _it('capture promise rejections and marks all tests as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, before }) => { + before(() => { + return new Promise((resolve, reject) => { + reject('failure'); + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('2 tests has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" before Hook: failure'); + }); + + _it('capture errors thrown in promises and marks all tests as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, before }) => { + before(() => { + return new Promise(() => { + true.should.equal(false); + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('2 tests has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" before Hook: AssertionError: expected true to be false'); + }); + + _it('captures errors thrown in asynchronous functions and marks all tests as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, before }) => { + before(async () => { + await new Promise(() => { + true.should.equal(false); + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('2 tests has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" before Hook: AssertionError: expected true to be false'); + }); + + _it('captures errors thrown in synchronous functions and marks all tests as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, before }) => { + before(() => { + true.should.equal(false); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('2 tests has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" before Hook: AssertionError: expected true to be false'); + }); + }); + + _describe('beforeEach hooks:', () => { + _it('capture promise rejections and marks test that follows as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + let testRuns = 0; + + testSuite.addTests(({ it, beforeEach }) => { + beforeEach(() => { + return new Promise((resolve, reject) => { + if (testRuns > 0) { + reject('failure'); + } else { + testRuns += 1; + resolve(); + } + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" beforeEach Hook: failure'); + }); + + _it('capture errors thrown in promises and marks test that follows as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + let testRuns = 0; + + testSuite.addTests(({ it, beforeEach }) => { + beforeEach(() => { + return new Promise((resolve) => { + if (testRuns > 0) { + true.should.equal(false); + } else { + testRuns += 1; + resolve(); + } + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" beforeEach Hook: AssertionError: expected true to be false'); + }); + + _it('captures errors thrown in asynchronous functions and marks test that follows as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + let testRuns = 0; + + testSuite.addTests(({ it, beforeEach }) => { + beforeEach(async () => { + await new Promise((resolve) => { + if (testRuns > 0) { + true.should.equal(false); + } else { + testRuns += 1; + resolve(); + } + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" beforeEach Hook: AssertionError: expected true to be false'); + }); + + _it('captures errors thrown in synchronous functions and marks test that follows as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + let testRuns = 0; + + testSuite.addTests(({ it, beforeEach }) => { + beforeEach(() => { + if (testRuns > 0) { + true.should.equal(false); + } else { + testRuns += 1; + } + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" beforeEach Hook: AssertionError: expected true to be false'); + }); + }); + + _describe('afterEach hooks:', () => { + _it('capture promise rejections and marks test that proceeded as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + let testRuns = 0; + + testSuite.addTests(({ it, afterEach }) => { + afterEach(() => { + return new Promise((resolve, reject) => { + if (testRuns > 0) { + reject('failure'); + } else { + testRuns += 1; + resolve(); + } + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" afterEach Hook: failure'); + }); + + _it('capture errors thrown in promises and marks test that proceeded as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + let testRuns = 0; + + testSuite.addTests(({ it, afterEach }) => { + afterEach(() => { + return new Promise((resolve) => { + if (testRuns > 0) { + true.should.equal(false); + } else { + testRuns += 1; + resolve(); + } + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" afterEach Hook: AssertionError: expected true to be false'); + }); + + _it('captures errors thrown in asynchronous functions and marks test that proceeded as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + let testRuns = 0; + + testSuite.addTests(({ it, afterEach }) => { + afterEach(async () => { + await new Promise((resolve) => { + if (testRuns > 0) { + true.should.equal(false); + } else { + testRuns += 1; + resolve(); + } + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" afterEach Hook: AssertionError: expected true to be false'); + }); + + _it('captures errors thrown in synchronous functions and marks test that proceeded as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + let testRuns = 0; + + testSuite.addTests(({ it, afterEach }) => { + afterEach(() => { + if (testRuns > 0) { + true.should.equal(false); + } else { + testRuns += 1; + } + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" afterEach Hook: AssertionError: expected true to be false'); + }); + }); + + _describe('after hooks:', () => { + _it('capture promise rejections and marks all tests as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, after }) => { + after(() => { + return new Promise((resolve, reject) => { + reject('failure'); + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('2 tests has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" after Hook: failure'); + }); + + _it('capture errors thrown in promises and marks all tests as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, after }) => { + after(() => { + return new Promise(() => { + true.should.equal(false); + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('2 tests has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" after Hook: AssertionError: expected true to be false'); + }); + + _it('captures errors thrown in asynchronous functions and marks all tests as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, after }) => { + after(async () => { + await new Promise(() => { + true.should.equal(false); + }); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('2 tests has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" after Hook: AssertionError: expected true to be false'); + }); + + _it('captures errors thrown in synchronous functions and marks all tests as failed', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, after }) => { + after(() => { + true.should.equal(false); + }); + + it('', () => { }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('2 tests has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" after Hook: AssertionError: expected true to be false'); + }); + }); +} + +export default failingHookTests; diff --git a/tests/__tests__/src/hooks/hookScopeTests.js b/tests/__tests__/src/hooks/hookScopeTests.js new file mode 100644 index 00000000..a809ccba --- /dev/null +++ b/tests/__tests__/src/hooks/hookScopeTests.js @@ -0,0 +1,278 @@ +import sinon from 'sinon'; +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function hookScopeTests({ it: _it, describe: _describe }) { + _describe('before hooks:', () => { + _it('apply only to the scope they are defined in and any child scopes', async () => { + const testSuite = new TestSuite('', '', {}); + + let value = 0; + let valueWhenOtherTestRuns = null; + let valueWhenSiblingTestRuns = null; + let valueWhenChildTestRuns = null; + + testSuite.addTests(({ it, before, context }) => { + context('', () => { + before(() => { + value = 1; + }); + + it('', () => { + valueWhenSiblingTestRuns = value; + }); + + context('', () => { + it('', () => { + valueWhenChildTestRuns = value; + }); + }); + }); + + it('', () => { + valueWhenOtherTestRuns = value; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueWhenOtherTestRuns.should.equal(0); + valueWhenSiblingTestRuns.should.equal(1); + valueWhenChildTestRuns.should.equal(1); + }); + + _it('only run once for the scope they apply', async () => { + const testSuite = new TestSuite('', '', {}); + const beforeHook = sinon.spy(); + + testSuite.addTests(({ it, before, context }) => { + context('', () => { + before(beforeHook); + + it('', () => { }); + + context('', () => { + it('', () => { }); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + beforeHook.should.be.calledOnce(); + }); + }); + + _describe('beforeEach hooks:', () => { + _it('apply only to the scope they are defined in and any child scopes', async () => { + const testSuite = new TestSuite('', '', {}); + + let value = 0; + let valueWhenOtherTestRuns = null; + let valueWhenSiblingTestRuns = null; + let valueWhenChildTestRuns = null; + + testSuite.addTests(({ it, beforeEach, context }) => { + context('', () => { + beforeEach(() => { + value = 1; + }); + + it('', () => { + valueWhenSiblingTestRuns = value; + }); + + context('', () => { + it('', () => { + valueWhenChildTestRuns = value; + }); + }); + }); + + it('', () => { + valueWhenOtherTestRuns = value; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueWhenOtherTestRuns.should.equal(0); + valueWhenSiblingTestRuns.should.equal(1); + valueWhenChildTestRuns.should.equal(1); + }); + + _it('are called once for every test in its scope', async () => { + const testSuite = new TestSuite('', '', {}); + const beforeEachHook = sinon.spy(); + + testSuite.addTests(({ it, beforeEach, context }) => { + context('', () => { + beforeEach(beforeEachHook); + + it('', () => { }); + + context('', () => { + it('', () => { }); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + beforeEachHook.should.be.calledTwice(); + }); + }); + + _describe('afterEach hooks:', () => { + _it('apply only to the scope they are defined in and any child scopes', async () => { + const testSuite = new TestSuite('', '', {}); + + let value = 0; + + testSuite.addTests(({ it, afterEach, context }) => { + context('', () => { + it('', () => { + value += 1; + }); + + context('', () => { + it('', () => { + value += 1; + }); + }); + + afterEach(() => { + value -= 1; + }); + }); + + it('', () => { + value += 1; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + value.should.equal(1); + }); + + _it('are called once for every test in its scope', async () => { + const testSuite = new TestSuite('', '', {}); + const afterEachHook = sinon.spy(); + + testSuite.addTests(({ it, afterEach, context }) => { + context('', () => { + afterEach(afterEachHook); + + it('', () => { }); + + context('', () => { + it('', () => { }); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + afterEachHook.should.be.calledTwice(); + }); + }); + + _describe('after hooks:', () => { + _it('apply only to the scope they are defined in and any child scopes', async () => { + const testSuite = new TestSuite('', '', {}); + + let value = 0; + + testSuite.addTests(({ it, after, context }) => { + context('', () => { + it('', () => { + value += 1; + }); + + context('', () => { + it('', () => { + value += 1; + }); + }); + + after(() => { + value -= 1; + }); + }); + + it('', () => { + value += 1; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + value.should.equal(2); + }); + + _it('are called once for every test in its scope', async () => { + const testSuite = new TestSuite('', '', {}); + const afterHook = sinon.spy(); + + testSuite.addTests(({ it, after, context }) => { + context('', () => { + it('', () => { }); + + context('', () => { + it('', () => { }); + }); + + after(afterHook); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + afterHook.should.be.calledOnce(); + }); + }); +} + +export default hookScopeTests; diff --git a/tests/__tests__/src/hooks/hooksCallOrderTests.js b/tests/__tests__/src/hooks/hooksCallOrderTests.js new file mode 100644 index 00000000..0cfa94cd --- /dev/null +++ b/tests/__tests__/src/hooks/hooksCallOrderTests.js @@ -0,0 +1,310 @@ +import sinon from 'sinon'; +import 'should-sinon'; +import assert from 'assert'; + +import TestSuite from '../lib/TestSuite'; + +function hooksCallOrderTests({ it: _it, describe: _describe }) { + _describe('before hooks:', () => { + _it('calls before hooks defined in the same context in the order they are defined', async () => { + const testSuite = new TestSuite('', '', {}); + + const beforeCallbackA = sinon.spy(); + const beforeCallbackB = sinon.spy(); + + testSuite.addTests(({ it, before }) => { + before(beforeCallbackA); + before(beforeCallbackB); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + beforeCallbackA.should.have.been.called(); + beforeCallbackB.should.have.been.called(); + + assert(beforeCallbackB.calledAfter(beforeCallbackA)); + }); + + _it('calls before hooks defined in child contexts after those in parent contexts', async () => { + const testSuite = new TestSuite('', '', {}); + + const beforeCallbackA = sinon.spy(); + const beforeCallbackB = sinon.spy(); + + testSuite.addTests(({ it, before, context }) => { + before(beforeCallbackA); + + context('', () => { + before(beforeCallbackB); + + it('', () => { }); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + beforeCallbackA.should.have.been.called(); + beforeCallbackB.should.have.been.called(); + + assert(beforeCallbackB.calledAfter(beforeCallbackA)); + }); + }); + + _describe('beforeEach hooks:', () => { + _it('calls beforeEach hooks defined in the same context in the order they are defined', async () => { + const testSuite = new TestSuite('', '', {}); + + const beforeEachCallbackA = sinon.spy(); + const beforeEachCallbackB = sinon.spy(); + + testSuite.addTests(({ it, beforeEach }) => { + beforeEach(beforeEachCallbackA); + beforeEach(beforeEachCallbackB); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + beforeEachCallbackA.should.have.been.called(); + beforeEachCallbackB.should.have.been.called(); + + assert(beforeEachCallbackB.calledAfter(beforeEachCallbackA)); + }); + + _it('calls beforeEach hooks defined in child contexts after those in parent contexts', async () => { + const testSuite = new TestSuite('', '', {}); + + const beforeEachCallbackA = sinon.spy(); + const beforeEachCallbackB = sinon.spy(); + + testSuite.addTests(({ it, beforeEach, context }) => { + beforeEach(beforeEachCallbackA); + + context('', () => { + beforeEach(beforeEachCallbackB); + + it('', () => { }); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + beforeEachCallbackA.should.have.been.called(); + beforeEachCallbackB.should.have.been.called(); + + assert(beforeEachCallbackB.calledAfter(beforeEachCallbackA)); + }); + + _it('calls beforeEach hooks after before hooks', async () => { + const testSuite = new TestSuite('', '', {}); + + const beforeCallbackA = sinon.spy(); + const beforeEachCallbackB = sinon.spy(); + + testSuite.addTests(({ it, before, beforeEach }) => { + before(beforeCallbackA); + beforeEach(beforeEachCallbackB); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + beforeCallbackA.should.have.been.called(); + beforeEachCallbackB.should.have.been.called(); + + assert(beforeEachCallbackB.calledAfter(beforeCallbackA)); + }); + }); + + _describe('after hooks:', () => { + _it('calls after hooks defined in the same context in the order they are defined', async () => { + const testSuite = new TestSuite('', '', {}); + + const afterCallbackA = sinon.spy(); + const afterCallbackB = sinon.spy(); + + testSuite.addTests(({ it, after }) => { + after(afterCallbackA); + after(afterCallbackB); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + afterCallbackA.should.have.been.called(); + afterCallbackB.should.have.been.called(); + + assert(afterCallbackB.calledAfter(afterCallbackA)); + }); + + _it('calls after hooks defined in child contexts before those in parent contexts', async () => { + const testSuite = new TestSuite('', '', {}); + + const afterCallbackA = sinon.spy(); + const afterCallbackB = sinon.spy(); + + testSuite.addTests(({ it, after, context }) => { + after(afterCallbackA); + + context('', () => { + after(afterCallbackB); + + it('', () => { }); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + afterCallbackA.should.have.been.called(); + afterCallbackB.should.have.been.called(); + + assert(afterCallbackA.calledAfter(afterCallbackB)); + }); + }); + + _describe('afterEach hooks:', () => { + _it('calls afterEach hooks defined in the same context in the order they are defined', async () => { + const testSuite = new TestSuite('', '', {}); + + const afterEachCallbackA = sinon.spy(); + const afterEachCallbackB = sinon.spy(); + + testSuite.addTests(({ it, afterEach }) => { + afterEach(afterEachCallbackA); + afterEach(afterEachCallbackB); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + afterEachCallbackA.should.have.been.called(); + afterEachCallbackB.should.have.been.called(); + + assert(afterEachCallbackB.calledAfter(afterEachCallbackA)); + }); + + _it('calls afterEach hooks defined in child contexts before those in parent contexts', async () => { + const testSuite = new TestSuite('', '', {}); + + const afterEachCallbackA = sinon.spy(); + const afterEachCallbackB = sinon.spy(); + + testSuite.addTests(({ it, afterEach, context }) => { + afterEach(afterEachCallbackA); + + context('', () => { + afterEach(afterEachCallbackB); + + it('', () => { }); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + afterEachCallbackA.should.have.been.called(); + afterEachCallbackB.should.have.been.called(); + + assert(afterEachCallbackA.calledAfter(afterEachCallbackB)); + }); + + _it('calls afterEach hooks before after hooks', async () => { + const testSuite = new TestSuite('', '', {}); + + const afterCallbackA = sinon.spy(); + const afterEachCallbackB = sinon.spy(); + + testSuite.addTests(({ it, after, afterEach }) => { + after(afterCallbackA); + afterEach(afterEachCallbackB); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + afterCallbackA.should.have.been.called(); + afterEachCallbackB.should.have.been.called(); + + assert(afterCallbackA.calledAfter(afterEachCallbackB)); + }); + }); + + _describe('when there are no tests in a context or any of its children', () => { + _it('then doesn\'t call any hooks', async () => { + const testSuite = new TestSuite('', '', {}); + + const beforeCallback = sinon.spy(); + const beforeEachCallback = sinon.spy(); + const afterCallback = sinon.spy(); + const afterEachCallback = sinon.spy(); + + testSuite.addTests(({ before, beforeEach, after, afterEach, context }) => { + context('', () => { + before(beforeCallback); + beforeEach(beforeEachCallback); + afterEach(afterEachCallback); + after(afterCallback); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + beforeCallback.should.not.have.been.called(); + beforeEachCallback.should.not.have.been.called(); + afterEachCallback.should.not.have.been.called(); + afterCallback.should.not.have.been.called(); + }); + }); +} + +export default hooksCallOrderTests; diff --git a/tests/__tests__/src/hooks/index.js b/tests/__tests__/src/hooks/index.js new file mode 100644 index 00000000..a444c6cb --- /dev/null +++ b/tests/__tests__/src/hooks/index.js @@ -0,0 +1,17 @@ +import TestSuite from '../lib/TestSuite'; + +import hooksCallOrderTest from './hooksCallOrderTests'; +import asynchronousHooksTests from './asynchronousHooksTests'; +import hookScopeTests from './hookScopeTests'; +import failingHookTests from './failingHookTests'; +import timingOutHookTests from './timingOutHookTests'; + +const suite = new TestSuite('Internal', 'Lifecycle methods', {}); + +suite.addTests(hooksCallOrderTest); +suite.addTests(asynchronousHooksTests); +suite.addTests(hookScopeTests); +suite.addTests(failingHookTests); +suite.addTests(timingOutHookTests); + +export default suite; diff --git a/tests/__tests__/src/hooks/timingOutHookTests.js b/tests/__tests__/src/hooks/timingOutHookTests.js new file mode 100644 index 00000000..3db70939 --- /dev/null +++ b/tests/__tests__/src/hooks/timingOutHookTests.js @@ -0,0 +1,327 @@ +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function failingHookTests({ it: _it, describe: _describe }) { + _describe('before hooks:', () => { + _it('timeout after 5 seconds by default', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, before }) => { + before(() => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 6000); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" before Hook: TimeoutError: before hook took longer than 5000ms. This can be extended with the timeout option.'); + }); + + _it('allows manually setting timeout', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, before }) => { + before({ timeout: 500 }, () => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 600); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" before Hook: TimeoutError: before hook took longer than 500ms. This can be extended with the timeout option.'); + }); + }); + + _describe('beforeEach hooks:', () => { + _it('timeout after 5 seconds by default', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, beforeEach }) => { + beforeEach(() => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 6000); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" beforeEach Hook: TimeoutError: beforeEach hook took longer than 5000ms. This can be extended with the timeout option.'); + }); + + _it('allows manually setting timeout', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, beforeEach }) => { + beforeEach({ timeout: 500 }, () => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 600); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" beforeEach Hook: TimeoutError: beforeEach hook took longer than 500ms. This can be extended with the timeout option.'); + }); + }); + + _describe('afterEach hooks:', () => { + _it('timeout after 5 seconds by default', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, afterEach }) => { + afterEach(() => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 6000); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" afterEach Hook: TimeoutError: afterEach hook took longer than 5000ms. This can be extended with the timeout option.'); + }); + + _it('allows manually setting timeout', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, afterEach }) => { + afterEach({ timeout: 500 }, () => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 600); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" afterEach Hook: TimeoutError: afterEach hook took longer than 500ms. This can be extended with the timeout option.'); + }); + }); + + _describe('after hooks:', () => { + _it('timeout after 5 seconds by default', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, after }) => { + after(() => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 6000); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" after Hook: TimeoutError: after hook took longer than 5000ms. This can be extended with the timeout option.'); + }); + + _it('allows manually setting timeout', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it, after }) => { + after({ timeout: 500 }, () => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 600); + }); + }); + + it('', () => { }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('Error occurred in "" after Hook: TimeoutError: after hook took longer than 500ms. This can be extended with the timeout option.'); + }); + }); +} + +export default failingHookTests; diff --git a/tests/__tests__/src/index.js b/tests/__tests__/src/index.js new file mode 100644 index 00000000..6e48e73e --- /dev/null +++ b/tests/__tests__/src/index.js @@ -0,0 +1,75 @@ +import 'babel-core/register'; +import 'babel-polyfill'; +import Promise from 'bluebird'; +import 'colors'; + +import RunStatus from './lib/RunStatus'; +import LifeCycleTestSuite from './hooks/index'; +import TestsTestSuite from './tests/index'; + +let successfulTests = 0; +let failingTests = 0; +const testErrors = {}; + +const suites = [ + LifeCycleTestSuite, + TestsTestSuite, +]; + +suites.forEach((suite) => { + suite.setStore({ + getState: () => { return {}; }, + }, (testSuiteAction) => { + if (testSuiteAction.message) { + console.error(testSuiteAction.message.red); + testErrors[suite.description] = { + message: testSuiteAction.message, + stackTrace: testSuiteAction.stackTrace, + }; + } + }, + (testAction) => { + const test = suite.testDefinitions.tests[testAction.testId]; + const testContext = suite.testDefinitions.testContexts[test.testContextId]; + + const description = (() => { + if (testContext.name && !test.description.startsWith(testContext.name)) { + return `${testContext.name} ${test.description}`; + } + + return test.description; + })(); + + if (testAction.status === RunStatus.OK) { + console.log(` ✅ ${description}`.green); + successfulTests += 1; + } else if (testAction.status === RunStatus.ERR) { + console.log(` ❌ ${description}`.red); + testErrors[test.description] = { + message: testAction.message, + stackTrace: testAction.stackTrace, + }; + failingTests += 1; + } + }); +}); + +Promise.each(suites, (suite) => { + console.log(`\n\n${suite.name} ${suite.description}:\n\r`); + return suite.run(); +}).then(() => { + console.log(`\n${successfulTests} tests passed.`); + + if (failingTests) { + console.log(`${failingTests} tests failed.`); + } + + if (Object.keys(testErrors).length > 0) { + console.log('\nErrors:'.red); + + Object.keys(testErrors).forEach((failingTestDescription) => { + const error = testErrors[failingTestDescription]; + console.error(`\n${failingTestDescription}: ${error.message} \n${error.stackTrace}`.red); + }); + } +}); diff --git a/tests/__tests__/src/tests/asynchronousTestTests.js b/tests/__tests__/src/tests/asynchronousTestTests.js new file mode 100644 index 00000000..1bda83a3 --- /dev/null +++ b/tests/__tests__/src/tests/asynchronousTestTests.js @@ -0,0 +1,82 @@ +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function asynchronousTestTests({ it: _it, describe: _describe }) { + _describe('tests', () => { + _it('can return a promise that is resolved before executing hooks and other tests', async () => { + let valueBySecondTest = null; + let valueByHook = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, after }) => { + let resolved = false; + + it('', () => { + return new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + it('', () => { + valueBySecondTest = resolved; + }); + + after(() => { + valueByHook = resolved; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondTest.should.equal(true); + valueByHook.should.equal(true); + }); + + _it('can be an asynchronous function that is awaited before executing hooks and other tests', async () => { + let valueBySecondTest = null; + let valueByHook = null; + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, after }) => { + let resolved = false; + + it('', async () => { + await new Promise((resolve) => { + setTimeout(() => { + resolved = true; + resolve(); + }, 500); + }); + }); + + it('', () => { + valueBySecondTest = resolved; + }); + + after(() => { + valueByHook = resolved; + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(); + + valueBySecondTest.should.equal(true); + valueByHook.should.equal(true); + }); + }); + +} + +export default asynchronousTestTests; diff --git a/tests/__tests__/src/tests/failingTestTests.js b/tests/__tests__/src/tests/failingTestTests.js new file mode 100644 index 00000000..2345524a --- /dev/null +++ b/tests/__tests__/src/tests/failingTestTests.js @@ -0,0 +1,146 @@ +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function failingTestTests({ it: _it, describe: _describe }) { + _describe('running a test that is a function that returns a promise', () => { + _it('correctly reports a failure when the promise is rejected', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it }) => { + it('', () => { + return new Promise((resolve, reject) => { + reject('failure'); + }); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('failure'); + }); + + _it('correctly reports a failure when an error is thrown', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it }) => { + + it('', () => { + return new Promise(() => { + false.should.equal(true); + }); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('AssertionError: expected false to be true'); + }); + }); + + _describe('running an async function test', () => { + _it('correctly reports a failure when an error is thrown', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it }) => { + it('', async () => { + false.should.equal(true); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('AssertionError: expected false to be true'); + }); + }); + + _describe('running an synchronous function test', () => { + _it('correctly reports a failure when an error is thrown', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it }) => { + it('', () => { + false.should.equal(true); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('AssertionError: expected false to be true'); + }); + }); +} + +export default failingTestTests; diff --git a/tests/__tests__/src/tests/focusedTestTests.js b/tests/__tests__/src/tests/focusedTestTests.js new file mode 100644 index 00000000..8c756cd8 --- /dev/null +++ b/tests/__tests__/src/tests/focusedTestTests.js @@ -0,0 +1,84 @@ +import sinon from 'sinon'; +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function focusedTestTests({ it: _it, describe: _describe }) { + _describe('when fit is used instead of it', () => { + _it('a test is marked as focused', async () => { + const focusedTest = sinon.spy(); + const otherTest = sinon.spy(); + + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, fit }) => { + fit('', focusedTest); + + it('', otherTest); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(Object.keys(testSuite.testDefinitions.focusedTestIds)); + + focusedTest.should.be.called(); + otherTest.should.not.be.called(); + }); + }); + + _describe('when fdescribe is used instead of describe', () => { + _it('child tests are marked as focused', async () => { + const focusedTest = sinon.spy(); + const otherTest = sinon.spy(); + + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, fdescribe }) => { + fdescribe('', () => { + it('', focusedTest); + }); + + it('', otherTest); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(Object.keys(testSuite.testDefinitions.focusedTestIds)); + + focusedTest.should.be.called(); + otherTest.should.not.be.called(); + }); + }); + + _describe('when fcontext is used instead of context', () => { + _it('child tests are marked as focused', async () => { + const focusedTest = sinon.spy(); + const otherTest = sinon.spy(); + + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, fcontext }) => { + fcontext('', () => { + it('', focusedTest); + }); + + it('', otherTest); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + await testSuite.run(Object.keys(testSuite.testDefinitions.focusedTestIds)); + + focusedTest.should.be.called(); + otherTest.should.not.be.called(); + }); + }); +} + +export default focusedTestTests; diff --git a/tests/__tests__/src/tests/index.js b/tests/__tests__/src/tests/index.js new file mode 100644 index 00000000..c31f777d --- /dev/null +++ b/tests/__tests__/src/tests/index.js @@ -0,0 +1,17 @@ +import TestSuite from '../lib/TestSuite'; + +import asynchronousTestTests from './asynchronousTestTests'; +import focusedTestTests from './focusedTestTests'; +import pendingTestTests from './pendingTestTests'; +import failingTestTests from './failingTestTests'; +import timingOutTests from './timingOutTests'; + +const suite = new TestSuite('Internal', 'Test Definitions', {}); + +suite.addTests(asynchronousTestTests); +suite.addTests(focusedTestTests); +suite.addTests(pendingTestTests); +suite.addTests(failingTestTests); +suite.addTests(timingOutTests); + +export default suite; diff --git a/tests/__tests__/src/tests/pendingTestTests.js b/tests/__tests__/src/tests/pendingTestTests.js new file mode 100644 index 00000000..e7c128a9 --- /dev/null +++ b/tests/__tests__/src/tests/pendingTestTests.js @@ -0,0 +1,108 @@ +import sinon from 'sinon'; +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function pendingTestTests({ it: _it, describe: _describe }) { + _describe('when xit is used instead of it', () => { + _it('a test is marked as pending', async () => { + const pendingTest = sinon.spy(); + const otherTest = sinon.spy(); + + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, xit }) => { + xit('', pendingTest); + + it('', otherTest); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + const testIdsToRun = Object.keys(testSuite.testDefinitions.tests).reduce((memo, testId) => { + if (!testSuite.testDefinitions.pendingTestIds[testId]) { + memo.push(testId); + } + + return memo; + }, []); + + await testSuite.run(testIdsToRun); + + pendingTest.should.not.be.called(); + otherTest.should.be.called(); + }); + }); + + _describe('when xdescribe is used instead of describe', () => { + _it('child tests are marked as pending', async () => { + const pendingTest = sinon.spy(); + const otherTest = sinon.spy(); + + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, xdescribe }) => { + xdescribe('', () => { + it('', pendingTest); + }); + + it('', otherTest); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + const testIdsToRun = Object.keys(testSuite.testDefinitions.tests).reduce((memo, testId) => { + if (!testSuite.testDefinitions.pendingTestIds[testId]) { + memo.push(testId); + } + + return memo; + }, []); + + await testSuite.run(testIdsToRun); + + pendingTest.should.not.be.called(); + otherTest.should.be.called(); + }); + }); + + _describe('when xcontext is used instead of context', () => { + _it('child tests are marked as pending', async () => { + const pendingTest = sinon.spy(); + const otherTest = sinon.spy(); + + const testSuite = new TestSuite('', '', {}); + + testSuite.addTests(({ it, xcontext }) => { + xcontext('', () => { + it('', pendingTest); + }); + + it('', otherTest); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }); + + const testIdsToRun = Object.keys(testSuite.testDefinitions.tests).reduce((memo, testId) => { + if (!testSuite.testDefinitions.pendingTestIds[testId]) { + memo.push(testId); + } + + return memo; + }, []); + + await testSuite.run(testIdsToRun); + + pendingTest.should.not.be.called(); + otherTest.should.be.called(); + }); + }); +} + +export default pendingTestTests; diff --git a/tests/__tests__/src/tests/timingOutTests.js b/tests/__tests__/src/tests/timingOutTests.js new file mode 100644 index 00000000..88aac930 --- /dev/null +++ b/tests/__tests__/src/tests/timingOutTests.js @@ -0,0 +1,84 @@ + +import 'should-sinon'; + +import TestSuite from '../lib/TestSuite'; + +function timingOutTests({ it: _it, describe: _describe }) { + _describe('tests', () => { + _it('time out after 5 seconds by default', { timeout: 7000 }, async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it }) => { + it('', () => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 6000); + }); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('TimeoutError: Test took longer than 5000ms. This can be extended with the timeout option.'); + }); + + _it('can set custom timeout', async () => { + const testSuite = new TestSuite('', '', {}); + const testSuiteStatuses = []; + const testStatuses = []; + + testSuite.addTests(({ it }) => { + it('', { timeout: 500 }, () => { + return new Promise((resolve) => { + setTimeout(() => { + resolve(); + }, 1000); + }); + }); + }); + + testSuite.setStore({ + getState: () => { return {}; }, + }, (value) => { + testSuiteStatuses.push(value); + }, (value) => { + testStatuses.push(value); + }); + + await testSuite.run(); + + const lastTestSuiteStatus = testSuiteStatuses[testSuiteStatuses.length - 1]; + + lastTestSuiteStatus.progress.should.equal(100); + lastTestSuiteStatus.status.should.equal('error'); + lastTestSuiteStatus.message.should.equal('1 test has error(s).'); + + const lastTestStatus = testStatuses[testStatuses.length - 1]; + + lastTestStatus.status.should.equal('error'); + lastTestStatus.message.should.equal('TimeoutError: Test took longer than 500ms. This can be extended with the timeout option.'); + }); + }); +} + +export default timingOutTests; diff --git a/tests/android/app/BUCK b/tests/android/app/BUCK new file mode 100644 index 00000000..dbc66ee0 --- /dev/null +++ b/tests/android/app/BUCK @@ -0,0 +1,66 @@ +import re + +# To learn about Buck see [Docs](https://buckbuild.com/). +# To run your application with Buck: +# - install Buck +# - `npm start` - to start the packager +# - `cd android` +# - `keytool -genkey -v -keystore keystores/debug.keystore -storepass android -alias androiddebugkey -keypass android -dname "CN=Android Debug,O=Android,C=US"` +# - `./gradlew :app:copyDownloadableDepsToLibs` - make all Gradle compile dependencies available to Buck +# - `buck install -r android/app` - compile, install and run application +# + +lib_deps = [] +for jarfile in glob(['libs/*.jar']): + name = 'jars__' + re.sub(r'^.*/([^/]+)\.jar$', r'\1', jarfile) + lib_deps.append(':' + name) + prebuilt_jar( + name = name, + binary_jar = jarfile, + ) + +for aarfile in glob(['libs/*.aar']): + name = 'aars__' + re.sub(r'^.*/([^/]+)\.aar$', r'\1', aarfile) + lib_deps.append(':' + name) + android_prebuilt_aar( + name = name, + aar = aarfile, + ) + +android_library( + name = 'all-libs', + exported_deps = lib_deps +) + +android_library( + name = 'app-code', + srcs = glob([ + 'src/main/java/**/*.java', + ]), + deps = [ + ':all-libs', + ':build_config', + ':res', + ], +) + +android_build_config( + name = 'build_config', + package = 'com.reactnativefirebasedemo', +) + +android_resource( + name = 'res', + res = 'src/main/res', + package = 'com.reactnativefirebasedemo', +) + +android_binary( + name = 'app', + package_type = 'debug', + manifest = 'src/main/AndroidManifest.xml', + keystore = '//android/keystores:debug', + deps = [ + ':app-code', + ], +) diff --git a/tests/android/app/build.gradle b/tests/android/app/build.gradle new file mode 100644 index 00000000..f767d583 --- /dev/null +++ b/tests/android/app/build.gradle @@ -0,0 +1,144 @@ +apply plugin: "com.android.application" + +import com.android.build.OutputFile + +/** + * The react.gradle file registers a task for each build variant (e.g. bundleDebugJsAndAssets + * and bundleReleaseJsAndAssets). + * These basically call `react-native bundle` with the correct arguments during the Android build + * cycle. By default, bundleDebugJsAndAssets is skipped, as in debug/dev mode we prefer to load the + * bundle directly from the development server. Below you can see all the possible configurations + * and their defaults. If you decide to add a configuration block, make sure to add it before the + * `apply from: "../../node_modules/react-native/react.gradle"` line. + * + * project.ext.react = [ + * // the name of the generated asset file containing your JS bundle + * bundleAssetName: "index.android.bundle", + * + * // the entry file for bundle generation + * entryFile: "index.android.js", + * + * // whether to bundle JS and assets in debug mode + * bundleInDebug: false, + * + * // whether to bundle JS and assets in release mode + * bundleInRelease: true, + * + * // whether to bundle JS and assets in another build variant (if configured). + * // See http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Build-Variants + * // The configuration property can be in the following formats + * // 'bundleIn${productFlavor}${buildType}' + * // 'bundleIn${buildType}' + * // bundleInFreeDebug: true, + * // bundleInPaidRelease: true, + * // bundleInBeta: true, + * + * // the root of your project, i.e. where "package.json" lives + * root: "../../", + * + * // where to put the JS bundle asset in debug mode + * jsBundleDirDebug: "$buildDir/intermediates/assets/debug", + * + * // where to put the JS bundle asset in release mode + * jsBundleDirRelease: "$buildDir/intermediates/assets/release", + * + * // where to put drawable resources / React Native assets, e.g. the ones you use via + * // require('./image.png')), in debug mode + * resourcesDirDebug: "$buildDir/intermediates/res/merged/debug", + * + * // where to put drawable resources / React Native assets, e.g. the ones you use via + * // require('./image.png')), in release mode + * resourcesDirRelease: "$buildDir/intermediates/res/merged/release", + * + * // by default the gradle tasks are skipped if none of the JS files or assets change; this means + * // that we don't look at files in android/ or ios/ to determine whether the tasks are up to + * // date; if you have any other folders that you want to ignore for performance reasons (gradle + * // indexes the entire tree), add them here. Alternatively, if you have JS files in android/ + * // for example, you might want to remove it from here. + * inputExcludes: ["android/**", "ios/**"], + * + * // override which node gets called and with what additional arguments + * nodeExecutableAndArgs: ["node"] + * + * // supply additional arguments to the packager + * extraPackagerArgs: [] + * ] + */ + +apply from: "../../node_modules/react-native/react.gradle" +apply from: "../../node_modules/react-native-vector-icons/fonts.gradle" + +/** + * Set this to true to create two separate APKs instead of one: + * - An APK that only works on ARM devices + * - An APK that only works on x86 devices + * The advantage is the size of the APK is reduced by about 4MB. + * Upload all the APKs to the Play Store and people will download + * the correct one based on the CPU architecture of their device. + */ +def enableSeparateBuildPerCPUArchitecture = false + +/** + * Run Proguard to shrink the Java bytecode in release builds. + */ +def enableProguardInReleaseBuilds = false + +android { + compileSdkVersion 25 + buildToolsVersion '25.0.2' + + defaultConfig { + applicationId "com.reactnativefirebasedemo" + minSdkVersion 16 + targetSdkVersion 25 + versionCode 1 + versionName "1.0" + ndk { + abiFilters "armeabi-v7a", "x86" + } + } + splits { + abi { + reset() + enable enableSeparateBuildPerCPUArchitecture + universalApk false // If true, also generate a universal APK + include "armeabi-v7a", "x86" + } + } + buildTypes { + release { + minifyEnabled enableProguardInReleaseBuilds + proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro" + } + } + // applicationVariants are e.g. debug, release + applicationVariants.all { variant -> + variant.outputs.each { output -> + // For each separate APK per architecture, set a unique version code as described here: + // http://tools.android.com/tech-docs/new-build-system/user-guide/apk-splits + def versionCodes = ["armeabi-v7a": 1, "x86": 2] + def abi = output.getFilter(OutputFile.ABI) + if (abi != null) { // null for the universal-debug, universal-release variants + output.versionCodeOverride = + versionCodes.get(abi) * 1048576 + defaultConfig.versionCode + } + } + } +} + +dependencies { + compile project(':react-native-firebase') + compile project(':react-native-vector-icons') + compile fileTree(dir: "libs", include: ["*.jar"]) + compile "com.android.support:appcompat-v7:24.0.0" + compile "com.facebook.react:react-native:+" // From node_modules +} + +// Run this once to be able to run the application with BUCK +// puts all compile dependencies into folder libs for BUCK to use +task copyDownloadableDepsToLibs(type: Copy) { + from configurations.compile + into 'libs' +} + +apply plugin: 'com.google.gms.google-services' diff --git a/tests/android/app/google-services.json b/tests/android/app/google-services.json new file mode 100644 index 00000000..30a94c5d --- /dev/null +++ b/tests/android/app/google-services.json @@ -0,0 +1,42 @@ +{ + "project_info": { + "project_number": "305229645282", + "firebase_url": "https://rnfirebase-b9ad4.firebaseio.com", + "project_id": "rnfirebase-b9ad4", + "storage_bucket": "rnfirebase-b9ad4.appspot.com" + }, + "client": [ + { + "client_info": { + "mobilesdk_app_id": "1:305229645282:android:efe37851d57e1d05", + "android_client_info": { + "package_name": "com.reactnativefirebasedemo" + } + }, + "oauth_client": [ + { + "client_id": "305229645282-j8ij0jev9ut24odmlk9i215pas808ugn.apps.googleusercontent.com", + "client_type": 3 + } + ], + "api_key": [ + { + "current_key": "AIzaSyCzbBYFyX8d6VdSu7T4s10IWYbPc-dguwM" + } + ], + "services": { + "analytics_service": { + "status": 1 + }, + "appinvite_service": { + "status": 1, + "other_platform_oauth_client": [] + }, + "ads_service": { + "status": 2 + } + } + } + ], + "configuration_version": "1" +} diff --git a/tests/android/app/proguard-rules.pro b/tests/android/app/proguard-rules.pro new file mode 100644 index 00000000..48361a90 --- /dev/null +++ b/tests/android/app/proguard-rules.pro @@ -0,0 +1,66 @@ +# Add project specific ProGuard rules here. +# By default, the flags in this file are appended to flags specified +# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt +# You can edit the include path and order by changing the proguardFiles +# directive in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# Add any project specific keep options here: + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Disabling obfuscation is useful if you collect stack traces from production crashes +# (unless you are using a system that supports de-obfuscate the stack traces). +-dontobfuscate + +# React Native + +# Keep our interfaces so they can be used by other ProGuard rules. +# See http://sourceforge.net/p/proguard/bugs/466/ +-keep,allowobfuscation @interface com.facebook.proguard.annotations.DoNotStrip +-keep,allowobfuscation @interface com.facebook.proguard.annotations.KeepGettersAndSetters +-keep,allowobfuscation @interface com.facebook.common.internal.DoNotStrip + +# Do not strip any method/class that is annotated with @DoNotStrip +-keep @com.facebook.proguard.annotations.DoNotStrip class * +-keep @com.facebook.common.internal.DoNotStrip class * +-keepclassmembers class * { + @com.facebook.proguard.annotations.DoNotStrip *; + @com.facebook.common.internal.DoNotStrip *; +} + +-keepclassmembers @com.facebook.proguard.annotations.KeepGettersAndSetters class * { + void set*(***); + *** get*(); +} + +-keep class * extends com.facebook.react.bridge.JavaScriptModule { *; } +-keep class * extends com.facebook.react.bridge.NativeModule { *; } +-keepclassmembers,includedescriptorclasses class * { native ; } +-keepclassmembers class * { @com.facebook.react.uimanager.UIProp ; } +-keepclassmembers class * { @com.facebook.react.uimanager.annotations.ReactProp ; } +-keepclassmembers class * { @com.facebook.react.uimanager.annotations.ReactPropGroup ; } + +-dontwarn com.facebook.react.** + +# okhttp + +-keepattributes Signature +-keepattributes *Annotation* +-keep class okhttp3.** { *; } +-keep interface okhttp3.** { *; } +-dontwarn okhttp3.** + +# okio + +-keep class sun.misc.Unsafe { *; } +-dontwarn java.nio.file.* +-dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement +-dontwarn okio.** diff --git a/tests/android/app/src/main/AndroidManifest.xml b/tests/android/app/src/main/AndroidManifest.xml new file mode 100644 index 00000000..c51b08ae --- /dev/null +++ b/tests/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,51 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/android/app/src/main/assets/fonts/Entypo.ttf b/tests/android/app/src/main/assets/fonts/Entypo.ttf new file mode 100644 index 0000000000000000000000000000000000000000..1c8f5e910bfb1a4a2871eeedc6eae01ca25e7ce1 GIT binary patch literal 65584 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 Mo)UlS#?4!Q1Drm*)Bpeg literal 0 HcmV?d00001 diff --git a/tests/android/app/src/main/assets/fonts/EvilIcons.ttf b/tests/android/app/src/main/assets/fonts/EvilIcons.ttf new file mode 100644 index 0000000000000000000000000000000000000000..b270f985192fa301fac5e3daeff0b96c15fc6b09 GIT binary patch literal 13128 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 z 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 d0mvn&T$mW6F>83$}^0}g;q zFklvAlUa7x3%th?449l*4D2H;EOA-(k=Z4D2Djet-0B{UWD$1vzi+0yy6V=gTeogF z_nhAeC6OdafpnXsNQX9V+`aYk_vC+rlt17*c-pSn`q~xe|4Nc5gX0VLUUktSDfsor zaeNrxllESJ-H=qrzx0)JaXxYBq06qi$3DCQ$A=`zdf>8)uEnnu!SQbVnwK58@zVd? z|DPKrNq$_C9>4YSeHUHw^sC?h21)wRN}O+Bjs)eG^0#n&9gasXzv{ZfulrA_gX338 zl6w7ttM^{CW2}t4A48e)!c`X?K18pz-y%t$*pB=|2QRv6-{#BCd^3)5U-@l^uDO`+rC*Yye^HVDUVQoKrO&N;{Xg>W7gnu$+2XHChv`2h z4OzC(rAR%w_xo!pE8U6GC0*gX;UB8A__zJi4VOqy{8IW=j-EL3gfv4>NNaFX+^Lso zNF4F?{2lC_TZtpiH7Kdl5Pntsy(BS$3Zm(r0VL3kdgNIzO2$w=Vu(!Zs5Tblm= zuYFmH;(=aGd(d)*BsHRqXtfb7M_+iurI*s4?%Si(5G|9U-Lzktl-8ov%E?AOPl-u- z#&4oLTxvy|jbWS@d5l(bmfEdmrKBelX+y_l^Hir(G8x-m{6@Mzi$o|E$=Lh#PBK%< zq?T*ei)|_v?1G(l!moua%}B&T(wnAqHRt6MgM*1dKc^T|PB;p5dK*1QN}%^=Bxy92 zOz5airP+x$+KqZTo~S1)^)^=}(OE&wNh;;#8md#Pw`%kj*)h8}o3{EP(rs7$Fnu!> z1gS{N8M2+CQ&bhhu_G#->R8=(5*ZOb`*qu<`yB^kOp<)sOV>z_l$Od;4Q<2?guAbz zW4UnoN{y*6*2pJv#L}r>*W%v+Yxm}<#>j1&9xMEk%|lkT|QV$jri~OM^eQ> z><&af5*@&9_unk*qqY&4?=gdmgQ3(=sf11NIPYdMVpnrq^>H&6GX-^b=mC1Rl#`Z8 zO^hT=>q#2M?N`a%j*Z%I18td1C5?8qGD$5lv8h}#bhL22Qys1j(*v$W-Pe%iY7>e{ zgXG9#+MP1VYC-Sl1&v5vLngh2)(v$3gVMjXT-W+78OA2V-av+at12rybbW^+t7psd zPiJ|IlSD`UKqb0UN=j0v(rM4*&Y0m$_fi3&d8)FeD%OH`ox9pFwL2BlP#)I}<1L=| z7GHnA#>*ngS%xvP9W+adw=p03bTy&R5;yM?y8l+sd#lJ#r)j2v;=F}^abZ3BWu#CK zy;@m?M;F8fm$$_jGd``G;)%5)}(5ozeqB@vTqGwp!Sw8_Nx2XAzZptu8COPmrde>cyP~^69$@sx9YaMf=GK z((pW3&5t}GOW+(5(ga$j&G$U!zLgf~T)V{@cDRbEWKLE!wYW>ySLpiAf-36|t2+Jg z*hC^uy;r+5-J{ z%)sh(n{tAN(90mN&uF!FBO{yQft&rtxgQ<(qZ1@Pq!THFr|LR#o|;$DgjrSZzVSq< zXJgDBpOemAny7Hg;_?#4lEUqM-0e@0%56fDN&f(8;R@;b(r+jZO0htovF%PhW$1=a z;U}OZr?u1dbU`*i2dWjLq?h=lo~(23b_1gW;|t46N+jcIbyHkjQ6jpkCC~?C#z>dFh;QhMs*oY8zQ4@#GFc13`4o#Z56gwFDz1UWz*a5U(G|loWi|Fel#mn^Pz+Vi>YAxWR9Uv zk%otHZC$lumLfZ9Omj3fqA9wgn9)o+4^|L_EcQ^8#P{xI`w9wQ*G5iHd|N|c-5|9*~Z!+GpV4RhC+jy zMRbNWXP;$&J;45%XIolcv(B@bQOuCJ3lU7NaP(v0_z!0`VUaDPBGZ#@$8Vw@>F0WBX>WOd? zg$yHTJ470=iAJX)m_eMR+Zv^0N6uA;Dht~&_OwxhC`HjAqiyfZ?bq-s<3 z?S~FMa_C{l$>v59(fkuuvp(P|Bjcs1bp>>_ypK#dIW^KgW!H7PY?6}%1~Q8)4qe+! zS97tH;KxjQ7U+>8=~4j{x{)rgrgR)DXOuZJ1w2^EP?$Z8HrtKo+!cLGvDrE|NG1bi zziLfe>VAh0TGMCWa}QYHp!>BTNxo%uf0YbqEC4&jl6aGTKwG4=G=O#r`E~RnOP951 zjpfT^Eorodlk`o~9J9LTTNb_EYINWA6Klb`00+8dopIMY-Vw@$N6RYy>C!qUC^1Lb z;|k5*e*1s5T%+7NzNX))zv8%ZUv=xPOz(9`r{_S9wZXXzNkC;f^@6G=^{Rni4CqdQ zNj_*SsA0NY?Np6YrHm~Y0t4jTs3#hwCPqFV)>COC4eH7pP|fy-$kAQRCatbf#12eN zHddUnb!R;Bf~{hEowm$MnhMB3($YW!B4|qd`LY=}gNiL%Nzf&1R{Cx+{WK_mYGQeD zlMs&$N6$un+%E{ly>mE%1xPJvC6I)aDmzu84hU05R|w*RESI&iJ64WpVoXIqEDlLK zrAwq6@Wf();tsEsYv4igfJYB7yjrym1dbZkmQ{q|##x&4ati}v1vPjwW3gLugyo}} zoRb&SR&z#~AY)GH@0S0msj0PTJ)x^n4cqjD&WubNq%@k*_30#^iK*D0qN(>`ltygN z)O6R4*-?^l=mwUh8G)C!Q}lVaGg6Re4P%C|nKcG9XU{5MPw66Qnv-TLoizl)Z5yVG zJH1s_bhMl08CoBKBG9kr0*Qgl7;iS}kVs2$tl8kgYb}V5*p{m+sG1aogJf_YNl)1`t-tuv8G|Frm{eC z$MI%kSY`mn;dA82($DD?Kth^~J$6uuK-NJLYOBCGFa_(>IxTSipkyGy{L4Zd*R@tk zfC^WWtxomdOr0(@Vr~b^p{Jj5y5Yr)4!M@2@533|G*GYC59^L@A{PX_n>)y$pYEJ) zm}t??4YF!^=04rlvCf`+R%72g>Hs1bEu58pMLVPzB+3%%RtP0Z#;rhoQ3bsU`5TZ` zIn7%LLhs8AO^x60dG}SP@(*k+#UjdRBD($K>exVO+9T7OEau8PRu%l{yNCVwNkXnW za)dU~?NS>DQH)}yTdOF_YfWATWnT>rPCRgK^NP1@FdFAmp2z%ozTomZ(q$fV|XpJaAFY{m_XTH$)rtH+Qu zb$m@45Sx#^t(HunDws-`VZAC~QZBh`_etwX(|poediTZqMb?<+8dJ!$iu4V-MFQR( zujdsET`aogk{G6|lxE|z0ho;)5Koj{isl4#OQiJUosPOw!LhUR$E64;AcP~Z4p(3v z1dy)>q+zKlNx&7weCYIkb^IpESk19rx<67bk9?#&GE)8s_8!L0zxIA<0}}bf^Ect| zF5U>4;}3K%3H$S10e|bOMKSB5E%a}Pd+N7J>>;TxZftu!b3|$_W)%)jsZQ0@( z-Bbo*n>mk=G~g@S?syVtHl1;d!6*)xjCf)H?=>=dxx7W!>nY zs6pJMcPhL~{|wCzZZPJJ(WE(VR?LhO^`hdNQH%{{ZA7b$m^BlSD*6SO2e*|ht%C%+ z7c$ASF@vh<_W!uaz|u3v-%fWbEM>I01FA*}4b2U=T1Fd+7VNj?TeQrR{bu?vHQ|x8 zV^(CvbZqkcv}06d)pk6J?(tUyjxT5P6(c*~ZJ*Hd=3v;oZzv|Ri!JwGY1Fg4gy$%_ zrYpW;dNI#Yb=^QGG|d@nlj#OZ$_bVkLrWSwq#gb7_&*-kP)#yrBci zw^_PKx{}9-;NN;sbQ(-;v&sqq2I!J$P#h3Kko^)c*#?L&mbkK>G!l>tf#gAw6?uTn zf;54g^g;D`5N(jEhS=)h?VI(yoa+738eQ*xLf0?L7PHArBJG3uRa`g7C`us_by;@u zA5uIS!$4M|%76j^pYxYCUApO`g~Hzz3coSFtLxu2K9or$Z9C~jA+e-n-GTs=QYi2s zj-?>v=(i|woKTE2RVwKx8OBL^q*RLVH}6Fv-jXlV87W7vgC5L~#;_*NW8U=X8RKG6 zMs1SAEr!FQ5XJ>g)D93Pu|dnltYCYb~# zc_nZvi5P7vw+yD>%ug_xV<7Nu%X$iurmEhkswbJ&?B7FBR%w(|iI8X`)#TKWm-p!= z=tdG^4H6~RmKInCy%d;kZFmJZJ(e2gWdk}Ux=GWXRPeV$QKodg_&UgabB%~i-JjYK z{QTd>>%K?pG#z=iE4s+?h%A4!`Cf50VMiL@gT@pz>-!LoUkhG(1~mROjLJjO?b7|c z9@hF$vXCm!=2-lgt%PvFaJCXHGYAUyQZ7e3HL#$QG8S@P#gms0j(R&Im7;kc(tgB%{!$V$KJzXmNs6%m&uYhd zDgh3-sqqZp@h`MM0<(SUx?K>rzXd7#kwcK3jdK)m)WD$(qrAp2Xe&EuW4&C1_p10t;0xClrpkUrMj5dTrtgC(SAdPiZplE$`;m@3> zt(NtO`Ur0_=!7`tq-A0h8i!Byg0TY;zD;`YL>v= zg6abf>ZR9^W66nhctHpg>A<)WX-F=$bZc3ocSc+d{I!O1id0Y3n{>}{kI?-`CjcZ# zS{xvq50Rr3-R?v@8{$Sn2HuW@$ob`{XGZ`Va+*loP(l_Y9?f+{_dAPC@Oa?ZJ|%5* zFHnTcXe1U%_ylwnrS%dm796gB~rd;J@5l7FIk@6b}R_#kAT za;pNZBo8Kohttv?M=E_@cBVW-9bO?@*UAnB&KH2F%GN6jitdhC+$j6L?&Lgu_(6NU zbGh?jJFhuu`@=AKIF8l;i;MMWjG#Ac=FmNwk*iUq2~)y^EJa(Rx0~|#zH5t zN}=1t$!`fd^D@OYE>TuNqhsuYu*_}Wr)S>LJ9MHv9K$j{JhyXauZUIMAMU(Dfm^t{l%=H=l=t4y!({ZT*d|I!Xd7x%iq`RZ49 zBXI=sQee|Bm+XE`$TyNg=R$V%V6)Ja=A;E^?}5|ykVmXr!}U>&FaWhI^5Joq*1(D+ z$-G+)tZSDho~C19CUx^1I>;Y z>hGxg?P8(u)WWA0D)C4p9{D(xcWByvQgcrc<)Zd}0M_`*Wi#uja$8^B#+ z2uFt%qq>?VDLv2H8{X7rsa&MSYJxe%hQgh9{ZPI1GVNkrKVLbgrp!z!6}kD zbl*KP^6jxPd92#>oS}tm78YL;6Rs+~na&beNdfxz<Hm3A=`)CQ>(|ZF>)gJ zt!u!bcAjziFF$*;Z*6B4{C3MbbubnijIH1FThH3TNjs2~i^p^EW0JP?a?!f(Q7q(S=}x&#&Z|md+$q@rgwk+XOi*QLY9ePEF8oto`&s16{r!AETB2O)P&gfaDk-W zBe#3M{h8PQ?WfbZsi6C_Ace(07NojADI}Bq&jGO$Zo@>{d^9U1yFVAHuN2z@OSZ2T z`=~3gEyvgOFRtldP{WV*tBM=`iMoAM)TdV~p8rSd^o-i*z4kh`T|PLJP7kGzy~T%+ zk{*K8w6wf_e_#>+b3M|3zT=RX3I#AGbVy#$u|37>86W%p!ixb^1eB_WO4bxV- z0GJ)yeKFe)$PPCapN%8KVBp0V+_sE|6B9}ZdMmExiXbybv7<6nqL8lH% zFXmc6N?{Zh05n6*!!_v7Y6*yXz!hWxdCIj?QmX-RU_PQI(1@B~C6GoXA?Jjaf-PXf z{jtOsh?C4DvMC`f3Bl)sA8pRcV6XvoFe?X+ER_b=p9IfOA9Bs^6{hQ&^h(p+q9)ZS z+LcC6DWNNI{VS7sZk`&7G&rdAp%e`SI(`<=l@yvhciQy>Y%OaO?`)^y+hHxvplebHE_(#3JEOZxAarG8*5S=6l5j1lWV1$ zq`$>eGnS7L4g>`NN@G}y4o9K=3uKlw1(+lrwaWN)yMcZa@OIdrqfG#CB?g)xN3j7} z6T_Kt`*0646aYxA$&;X;q0z^#{_IudV=kk+Jg@sgOzgt|B_{6!&yP;TSC#|7aLanf zL#*`RgzmfQ_03R5nu?;jFnw?_VqtaWzATr`=1#HM0t2}~e_*&owE*hlwF03q)Q zz>PAhJi4uMs-M*LAkg)szoouyR90zBlT(w;^d-7}kgnGCed*RDW|1~_i=wS-O@r9z zXsx6^)m*0mrBuhJaG*i!nAE4Mn1HY&67zhXuA&XV`U*klPG|+YG6S8K$6k0q>m0t=~^@p@4V6JnuY;M~v zo8L3#-P=t0YM%4>9{C;Cf)`4ou&sj?BpcB3a1MuYbwo8zilHcK!oDw$?NJ+c!!N z(bd36V2eSZ?!0D05zP=5R&>_gLaZy0Mh`iE6;*T^vtHvSU@morAM1XNwnePhTrWpu zN^ACo4_Q$^PI2gxLZ0Yh880*IdAUFX3IyTKE zR=(`4AWVVV8ZYr>s83VLOT72G#g}(T`A1o9%JL}434YY3I*RXsVi5}^y~H(nhnmym zy0Zhh?!S=Ued-mXB)0%=$kdXFbF0m(x=&%T{-){u3b}O`fHLr>BTr)t-vJ&6lvmJA z?n-nXmdT!QAaE#Q|3(K)rBt68uFMs)krc4ms4+A>J6u^Yl%oyi+f;d^IPEd-^r*}EF2}89!c>T@J(*wWVIKmjT5PVcwdh4oH0pF;!rMYlwNAl$ zpLmlptrpd3tgO>af#qpD?}n)JJI;j7kZ!A)Pjd#&M=~-Y53GAJ7Q#B2cydTXBWUYd zvJ9KPKUF=jRPedTLoj8w3LQx`-!5HxqIzk%l`UnUpwJF!{~IRaf$`9B)%x8!Er@2b z(Lh_rLrBn*emniqR!X0+6`t|PTpkLAzQ6?Ttw8?ufH}aMVFFtX z`SR|ONGexyyyzX|JF#GL!S{06fl@XSPklF?P60guFGiQp#qa?uN@qapdI7X*H%a$N zuae#<{e6gt7$7cHa2d4*fO*!E8Hq9w!c|b$q!sWsI1L4MjVoQNg1i8zz`SKO6Htss zYhGa(x+vF^C1~DoWzvXNqiKAX;+~G6}n6jKp!&D3D^o^gFTtIs4e=Qm?;<{V%vR+Prxh=hz!1? zAYd`Ji{yh+iIFirPud?UBo&WHMUqC2NZXVFSsqXh$hHFxl+OdjF#&PHc7_XW%6wja z6nT*I%J7KC73=?8dOK_rLmwgVr%M|Kq7O_!Lgr00bg%J-mo(moO>>iJ!tMjx_Zh}! z)9n6Q9NcFfGV%G5*?lXlHO@4zFn(d0zc9ir?#uIbfbO7uy?Y;{k?jb+PcVB8;TZ#X zgS(J!HjM6lruhv``vyvN!n^&<+-l-;gRE}_aKF|3X?PscE17PlTj7H=1at_tzpO0- zpNr*?^&U{_v1y}F40RM*@#O|M=8HG#`lDogQQmmTCHL(! z=w&SSi~5gZ4LV2gy_k=qiwFz|5D=Lv5XBBgW~iN7Vv-T6TCnQUZQWNh&rX*)K`_$& z>>*Rj76Yg-rd&5UqbIb1rZr@3)Kc2um}-pz8&vHeu)BY-gZh`gl+m(T#|!Kc$4zcB z?YVO!vEU}lnP08*@+kUtoL)j_pnfe_Ze5J$$FkUG_!$;VW9l)5z!XF^d4U%)6gC}R zK{;!^!+d#2TFO;s4n&q#TJK=dg<>L=1iAD0?LTT@nQ7>8tJ2fd8y7?xJS zFt!Xw9rD!`I@A-(Nxu7>qBupP6>+M#OWCD5_LxtbCUPF>IS1y&YZRR!VIA1>D+oq# zhGVQiC+oX=0icRDV6ZV^)@Uu=1lqX{ zQuyT(3>$$>gXKwr|77b{9pWn#68wme$J!l8mEd+*Viul)yoff_y?u6p0>=g!#ei7| zEXklh<3{VmdrTgW*UF+R9mZQYd5$JQ+`r=VRXPQ>3O+}#84z}jghFvx!71Z&6Si;P z?k9Xp_lr}7!HXP6(>B6RL(@K!9|L6$+_f6orF3I~mLze#jUbG+-1G%c1b~ zyf@m!4NnT!HH}`4He{}gpPo(f1zX9kA8bg^%TAlBv+I(Hn4Z0oeZ8*C>aj#}-Rz3t zVY+GEY;k@dZ4|f5^7f*U9+)rAuAA!d;77W25$p`1;~!n5<3icZZHb;p)47^=p?kG^ zp{G5HsjnFS?s+eHiRb;hq1>*A`c)}KQ}78@SE9javYO)*=95X|Vy6ODON^zX zzLg`;Z?5C^U>>wbr(%b>UD;9KR}roq>*)iuGQ`+NfivinGIJBWfRuYX3iPU=i9GC6 zX)Gq`R39*<52)GzR`sHtwTom;n`@_P8#mU**Vu1x2cV4ZzILu!ovVIhNK;o;Eh~9i z4%O~WHb*I#d%zG;5J zfYrkqquV`uO>6)HFCAb!aUk(VaEJ%kT=f7vH+y>@gH5Vow73kNO9C=+L9av|CBpoj ztyYcwfdO~a&1fB5+#-`+Q`5>=Yfu>PuI4uyDk z91;=xod`f1c3eP2!SP@$*NxC}C>$#=G6I-}L5xQPWGu3j)3nvg*|M7jN4d2JdwUxh z2yYMp3I8Rn^T>IT=fPtFS?aRV2g1)F*}ET;nfc2AH2qni>BGPV+c++SD+aHZjODO{ z73 zg7HCc_xWR~3$U~6RX#g$Nkd7aGPf@`ZdS?p3jJ3 z|4V1VaUH(nw}sUFx!6U*zvBEw_+E*eVckaH5qvIcnF1fP3Ugo&C>l(8G2@JqQAHPG zkn{9wH{pHEm`Eqps5c>wV+$-G%&~N>TKWV__w$w>wOtcXjOis)sqws*48R_lj$?p> zu;BmXC+NVjPqg@iTP-8n*`=FS%#GMq%6~w1B9>|RwyPNy2vItGyyq@HGe4|o`<#f! z;e(>g0_ES%eCsI8D8(8o1BfYO8e{y14i-FSYk%f6*tihC5oJ`x=*I#8nuH|)XK1bC zyxVb3f#+Jw1u1MDb9fz}d$+S1`i&O+!7g+8d<*7pTHA5jnsM9l2@5T99BR2+`7Gzc zcw(a2f388c7>J5G2{{V%y0X~p{D4ai@NlB|?q?xVqMF^$0wcox@r#O%@}1hQG3THv z*nh4oel^0#TA{d!D*!X51MIe@zlweY|4Fn zZy}K!{1;36IG@30vc73keG-3^$mazHm!z|S1r-H1!L${`gk3&Rp4f*k5V%36%PE7M zXD}FFn<m$y3^a0wPUgsvMvj8GS-w| z(~Ia{XfFDk1}bT^m^O9F9Xw56tM;ZBUU=d9YH6om$@#QB^PJOHt~`C7?!EAZ7e;rI zpR4$%jZLqA%lzr{^8j3#?p0w|br#Akf$DAO(GLh2n5Bsl07@PJ8ZX&Mm<3h_kOYoW zyn6G>gf;^u#ug+|@G9J308wx8AXq(4@<)J#-VBI==t|lz-}79gc3;l2|BGe0VptRM zU59XvQHrZ&ItyA#KnMqk4q{32wiCSr+}5>6F&fdP_c?cu(+c= zns@>ny3xa-MPBgxVx*ufhM>_BtHgMMk*ByprzJRNu<;Xb??AulnXq5-pYOvKxwd;Zd}2-Q zFytWH+)27ltMpBVYI1OZ5SNkUj_>2@M|X z|II$cWd0Lvjy5%DS=f5|Vf2b^?E0gvw~Iy4!@9~b2rv(i{4@O>y$SX_DbSL#&>^lz zi$sCA^MrsMG(zJ*i&%#NQ42=cXc#ar1{`M7!z~#6qR9X!hEO7qKg^$Yf7+s8+36ni zAC->yx5Ur;#=+C?-FI`mwP_h;_A9v&7mgOHp^UjBZY~+2ROZWtVu}g08Ww$sz zMSFZreg4I+>>s=dZr+b-W=^(Es*&MBtEZ`xG~++lonAAwkoiek_SLQ4o&H9p`VG;>zl#f@jwO`37LJIk@rzn$1?*0n#Fa4VvF7WF!PyMpiBDuwel)jfJB)N zi3MqEX4l6Z^D#CUSU> ziyoGK51#NCoRVH{+uiGJ`}fX;4nDX&W|(y38`5{^&BzX(1I+|f?xKR;a26kmw2AL z`8kgw7J#M|&n)Vi3ITw$>Y=Kpj4KM*G%Ye2gvok(U52V&_w&$oH@xnLU0gf*Z~ulM zO%`8Mq$2chmIi~{DpgV7aIdf+AU?sjpme&|#yLFWrM+kTqtCarj&!Np{T%q0rW@Y5 z^1~l;d+``j=&P`Am#PQ>@|Fl zqC?&L;kD=f!HrItmWj_)6bF%R_lqbL_ZXxv(Co-`N23$ zI!;f@?h)y-GZ_ChX@?R~2CgxD&v^SX4jF({6&64D8OE}Y`Cj+yD3{CDff7H5tttdx z&CCOrh5lV6GbgM%&`1|pM<}^F)UGL1$@cb9I*zn zTat|(cmWI@RmC)7B^%3Ye2~W7k~Mmfm-YVoSoQQ@dz5kHCS+_ny!RL-_1+u6LpY)S zESxU}MI&R`Fmw|N~ zdi~ODmWp=*Kw`#zrs@0zAYz^j4JGOX|^m z`irOsJFNrsc-o|gx`#arU{RpCcUj%rY0o+4klB3|&=3T|8p?7z5``T5>}Nd14UTK*Q1oPc4S`V<08 z_4@fz(a)R2i2RHCc`+6fxDHI(&|Zd#8$&zBiMx6MMr|0SdH#{*!9iKZ5q>QG{UbfU z4=Mt_28M5t8u%iSJG_`>E9UFM{$Savgwa|95`_o?e_}kqcMGEeSSACP$u@Hm=r=wT z3+6LB^8_PiCYMVlfl*YOK`O{Oj=S-gZj+&Odq!j5na<3XT_-(~VRfAA;;QtLE)!$= z`>=c9Iky59Zhb^z>7ZtVdsH4ndC9E9>fQ5BO9Rnj_p}rDz-x8=4LdEHz35-V#a+2IU%X3+HU03^&fg8i(~&Ys9yqd+75U?A3`13=rQyU@6C3uK?tS% zxr$ex+0-KLz~XF4vd#-ECn9)+6Nf$}%jc{5>4vcf4sk0_L{T0^ugIPeVE#mOPoB_n zaR;trhAJi!;sn|}f1-!5?yi?*ZOE9@hajEG&p(Ft{3Dv;eWEEgFX^I8e>#D5apF+ibuH+=Er_f7(9G?n`JnPVD_{^G{jlg?zEw2O_OJ$^VJ*Crd$Cc9vje98ZC%m5fbbClbnQ98%A z5Ikp-U}IX1zn~r73sKAo24P~COJXt)v#aTRDw*_0{_>|E3IW zga6U&_zRxlFRp2?Uc7GE9JweC0)n;!4_p@J7m$Bfk$^k^1+*K&qtALB0uz1Hl8yIR za6vUJ>rV47gw5=pZkpdQt@rDKUOh>7(PM(A!Ll4$;w~<w=iO zvo3m`rk+Xem+(-NLT;@I3GrB>_zWHjDkRkYs4RKR+SBKnhOKeYMW>&CbU{!4y=6TF zinYeF&OGXS$$ZlH>1AR~S;@A!q;Sh{CFD?j)nk&xs?sX2k_B%^2>ZhjC37@b-@(7M z>q2V+UZz|^dFa0%o0e5FpS;RC2R5PvuFf+*yR4Lqj2o8i8Ds9U^*aVD`N2fIzZQZ4 z44CO)xk)g1pIg7o8aLd8F_ui0mMx4SsBs+PO*n^mtO~sJPpss}G)|9|JHf(>aid7; zk)I)!;DZ=5nJ`AOz%C%=3Zq!&U7*+NR1wA%{D5HORuinsFdNum9nWWd*0SDc+xM<8 zBMEcGfNia=9DD^`X(3wdpk3ftb1HI(OxC?~W+GzF4OrHfD+gbGx*H@0^YOrIa!5KB zrpjsMNzcl^GnWOhoz4&EGOy%o?j5+7 zuX$zQ1%V^ul0;ryVn=a_TAFMWaEXH2vg}-uegHW!%Ca+11_UC*AgVED26q;UFFj(d z-da~E3Et>*pfZ3N|JhFWdr(&tobFe}PZ&2k0$BMFW^{nkVVe;P#n^g^EtK)Jf`#T$ z*zXOr1o|R0GQ7MnRVYk-l{W=VDUS^fC6mL0V`W8)W=AJ-H(qlM>3lM8+YgA)^~9t;fMG&cu@rH~_}A=qtPh*42R6dYJkGpdAU$3%qBL}=QGB%`AvCG>0I zLt)W`9rQ(bfiPO{XK5i4S!%Ny88Z;KK@IjK29txPIX=1B4b-?Av4`U^*GqX3^#kT^ zPV>X8@?Zo390Par2f?~b_ z8JC2wHNw6g`7L4wzW~%Rf?*c2hIk$}k0daL4_MaIx7n^zqNf2W{buV5ny{^INp;QV zb&>E;VmZ@w*f6~x_BT273wttwMhLx15?UmHM66^VPKvn4FjP)*w}ik(QBH>4L+=9? z4PQj1dqb#szZ;;2?bf?*M?@Y?j&D^ROS_Ivx%_gvr2B3QwuBzc6gNRx4}aLtP~;oS zfD1j}wmw7jk!BOd2wbN=eh@Ie(zn;>L$Dp;e8W@?V^ zrLqkxOjmxXcuZ_`x)xXukY0f+GEf!5ovg251;|mcdOxh1Z`PGF6#ZsJw{Eu1uzqcy zuIe`d6Hsr`)zj^pZ2Klrm%8*V_-E|E7!Oq{(4V0~WyDp3eGt1UiGXvg#bkPqW&|aK zWPv;t5pEIqk64!k#)9)Hu%JK)Yw2X_TXJGNKJ6q1*=5OBrnNdmyZEZ=$yrk1u_3#K zST?az(`ISFHQgZ_Xps)ZJ1qMX2q{+JtC9t1ZBzO{dURQxLpG+Ad@>ptMiM%y5K;X= zR$*e!1ch1j^ zA>=8{=#(!yKXmXxow#lxp2m2DV6K2;u>dnG90%9~P|O}!u0TNIX~VHM>CVv0LzUm| zVT8fmuaB?MioUN$4@M)H4=qA$Vx2rf>*;x+PGA&sU9Tci9*++Zs00)g4N_U48E6Vp zv|h8`Z0UCcO23LUbp^C@cmEX8M&3SDAr7ec@0o~c{!IxR!W&y=u!8tMnjXa!0&<>%Ii7i$RmaO6MeVR{j0R*9ot z3r$xGk>!p>q2OWB50}7PAy%;xJ#4MZeJQ)%vesL_ve#LcT2EN?r2RqM{c-!W)9lBs zgSLHe0%+88e|GDw_VKg`NOhkUF;=$}pbW_n(6~?Zfw(>m8vevl#7&H62SH(;4V)Xg z1s*ZXH?zk*1nCf_W~PL}CBXSS|6x%;FR;4zBDBr3VZ7^F_nJ^STK8HoX1a37vWD!f z)(1^*fFm3tT%j@GnI9DE1I8%)g+}2obUFGE4h-<#=h>a$$(#hf8`*nojI7&4Gb&**Evp{h7WG0d4UW3~pJ+CBjgj>m$sU`FIqy}4Y&s?j) z^gTa;uzt>Z*<=F)#3SR=a5RBR)J6Coz*o5vV&3YoSteRA-A^EJeRz$%jxSNj)cF#? ztBB=`3r|8^NrVZUKr}!@TaU1W6r^;^WoHT3GA%^fBRH=BhLz5wchMN;OC4+d#Vj>& z!wPP%gJ{i|Fs$G+@R&!_VbLNimhfbJN?ZaX7))vo<=F0omxq_Y|1(U7U2iYF86@D* zFwnvR1Zx4MV9D16iA9)1wG|D#zSbAK^H>>&W0CkP%*V;&D2~`H>Op}?wCGx z|NaL<`wQA})OaGLq*tH0de+p25F%%Ea{q(-LsJWZqqm{QIR*243~?$p0)^r@mg4;? zVycJI3dSioXsEy7qFbqoz^I`27~UZIt7IGtyE`0IW-)j>?Iv(pM6+OefDsMj5+2UN zvII5=yq*~8n_%wTN{>6nhQUJ8f!~Ar81(J_M=ktaa}95A)$|thltlmg<(B^q-&&Ok zY}gJACsV_kVp@^xm(Xn)cVM~KHr1h6DO=JM+Y7QVpqArt2zRd^wp3^2QtW9;7SW+m z*h!kRoc*Jg!~5B>;|WBFN#_e`3ojr^*zOWLvH;w|th5H}`$ZuQ5qbr@?1k4mP?1ov z&^s1!J&-{t{^dHtUoM^&Zg>6s!1%@WoF7fY*+J1;b$ZPDv9i4-E??76i4VQHtqq>j;=}@2+CYFstXu}KCbJ-x^%Iw-ochX z`O4ISymrdQ>H zbLIjeVkNYgn7O#-)GOg*M`1kxiC?{w>3O8JS6ymMSsuZ_yIx67de0{ znFDwL-zPK`o}bnO^3kRLY7V{LbNvk0o;2+e@j(lWDuCn)X$fR04gUfxcU7pvCozCA zej6IXvmBS!f{c>NS8};ZuDIn&MDi_0-~m^os4pXGT3z;r;FI*Cy}jdG-+67WlFe2g z+`lCTzs5+cwn5~0cX+h-K3tFd?_}D*^wp>DA>LgQ7GZhVVse~sjy)i-hB&A}96(S_ zF&fnXW?=@up5%L8x8u6iw?Xanwu;xy@6PYZe9jp&Rcn$5~;IJ@}Etj)~|JrgLzwzk(viv|a zhO~P5udF{{tDd7|M@H&pcekF=ce~~K$VgT_yMM1=gXg`Mv9A8T$~`k4^mLW=r=dc) ze@{FiEQw0+Vv{5aZil`&oERPd3 zxl~r4hs?pMFo&V9ba6;4S1QQouLhuuY__)G;t;8_;7@-|XQIv=&s&P8lX$-YjBZ<< zC`fJ#CeX>o-~0{j-Lz>h{Y_&7-FV}TbkE-FH(zO*S8l%klJ3LimZtuyjXV4O?bCZj zEJc>kc-7{h76P>tMjnm&aH9fj>b(duakc5nv0~=j1LtIlvF>}nKDqX!r@qE!A76{j zEMGp;lP4AET5iFLV(|!SW0B{Gy7dH{))D*+VdQiJP^R!w2BpNE7HD1u@yX+d*#mIf z7Zi%ccdsmc3QA)*v_!g3!f6PSr7Z)myvVTIFFn<;=~Pu&iNDw5^$13QrCUbi%J0}v zD4Mo8j3EB<^LjjGmcBrjL24gmjVs)pgi#*HRRV8OOCMFVzz&ygK$fMz`|%NHnS3q~!bu|<{D3l!x775;4I2j)Q2 z5Qxk=!#CdDg4X=@=}y~~&E*a~%Azt1k_w~kww?#gl)Dh#Sa*`wKS0iMQ+D5t_Xxp| z4}Z*u|Bmhlf61|u&PPunWV>DkXay?WsU|T>t1W{`77k&g$(0P}2}UpWfrDYeHPWCJ z9qgkY*zpPLF9PC1vES~yWb~O8dcH-L6Hy#1VAt5V>MvS*)aFQ8#4h$F# zQr;N86aja_>kz&a_+BA`mo%w9;#(;An0PMAR^(`J_kFan`@Xd=`odcDjf}PH zFl>z)=$W%Q5`UaSoHa$apeIDThHq`bm_*ZZi;Gm4tM$*O+bv{8qhlnuG3N1q%o}0Q zgXoJo_|<;r@@ridU}(iJNGoGLblRVUM=1W3WF!Z(6+LITidC8GjAGG=;w@Gwm^|Wr zC5US+=g0HIB(Kj^?UVy?I_^iGXW6h)U0Ace<5XZ?ijegq*0S+Rb#$DRF(7P896`;Q z?E#Z2%dljLBHn>wq>!kj^f)Al06ZCh0e3u_%SI+Pl#2-j$4{UjEryqCXmUnVMhoi_ z#zjF5j=vK@L`Fo;h>m!ia>XoyWFopkT+JY|h!LYPviy8P1@DhnnSjS-cV*4cAagL^ z3Ocb9IAt8XLJ_emc1RbZ%~Q!T+xswSV-kS59}s&KB!pi9$CtpI0KMY{7H>8HVGz(5 z(nO>SB$Rm4GzCdy+Fb>~mc=~ci@v?$Usm9~f(pg5Gg+|%bj-Tivh3S@gkJP*$DjA$ zlL&+l4O)t0i~7f+x>B-zHDPHm+T5F8xiUY5?vRR3s%~kt?7%WLTFcBNrZ?wCwOnpQBPD-LBAZzmi!E>8Fx-sA@+EnA zsHl{1Kem@J=_ft$I(4+h2pRSBYb#foQT#5+RZUI6J^l{Y$Lqq_MBLOI7X zBO|}abf1W8T7nj`e-)SIxN-m{{Gi#B@@r(>D~?8@MI%tP!AML=#qsJK6)2zXo)kgo zI)Nt-!7uzmv`T?>F#P~8oyE5?g)|xZ%Opl2{B+@$|DN7cEm~989TOay@E(ng~B5nHf((T)T&G}?uodm^jn~lbQW3Z+;A*HK(YsPA>U%_S)Tc5$Jrrc zJ9g;sNcK0J8=LRWA1T?^@SJN=qotL3X;3urI8zcZl@xzN6-f*bqWq6Z^*gU+!5yq^Z zPSg?DHPI+4uw&&Y>Uc_&qSVtEiLmY@zc^Tzhe%B;vkO6TwN})scv~3)eyKq1qq#{0 zu6oHEcx~IKU`~TL@{9(d0udY@Xe6|l;>U`npr)-sW3Hz3~&r9K+z@&K@w2IH&5S=N9aC@io9*v z!pTF1u`Zi`F+W!IqD~MjPYmWz#Su6d#G*!V7CM($jO}%?rPV?ANgpqn3;y}M^7ZW6 zLB(bJJUeH|k-Bz0O1y%imaYxYSjjta^mRm$kh5h+UhVw~Wqd)DQTJlqchR)(cfZWw zG3)J5q5nl~(3~<5`%T~sFOUw1`1k^W#W2P&T?PA1hCS!yM9Qdha8nHA25=f#q>CI_ z2|yr`sUiGySrdWuDx|;OwRqvKxE2O^(4vbgp%LOR9T;JWGW{=ozospS&y_0G)U2$o z*EEr)+hcIIT&HA#(|O5@?$>1GwGMlfz|em4Yy;a9+Vh!@&bsywOT&sgTnU@Kyz|DpUU<^slU{P|jr2t_ zul?e+XbOSpnRK6cuU6>i3rszZYm%L`!E#Us5)a;hku<8U^s{$7dk256-+tY7+ppib zb7%S4*Olq;`b}$YU%Pqz`ps*%e16TQ^*>mj&Tib8P50!HZIDMCtaJxZE;P2Q!G7W0 z3gwUwW6dUu$?3WQ#0bzeD98kqSl9#74HTS7PYW^NAZq!74q;Y`H&BW|L@i87aOgsA z0ZjsH2hziK_U&QMR%tVMEwu|y6*0*MMM?m&Pfy#vZ9++glb4xU}z9}*YQt{z%T(|Ir!%cA|SGnvJsV4_db0PwgWbn zMuA&}bgC>?8>TZ@#9?jC%Sj7MK9(3^PtzmCbgt=n=K0Hv&R{+m9I7r`_6`=d=`cj` z_n7XBmyZn8lxlf=`HPW=w}0Rs3clez!Wgr>svSem`T}16m$n|2LTZ3d>gD(GwnT@Q zN(}#j^!`WSGe5&i5?{(um^EI7VBR6VlZO2;&0(M*?yn z)*{;nV0}tKAg_1sUiTWj(NG2C`Ek5gRaFlH6~${735@5%{y4tkXVZbYTX2UQ=PCnl zV~jXIU-u9q^x3#ZJ!o4)YJ~hT|8+h-;%C#9br-pZkR9PT(5$`r#P6vK;4Lr>?gq5w z8SN`{JE%5fmZk=xf<3Tr9MQ4^WnnKKt9WM#cQ_+WkQ0`4!Z&x$)za-kCf5ByI~WJ~ zQ?kXusrfU7NybA%)6+wP6Iw}49NR&;x$))s*?6uvzI%0fL|JXw zPbh9D=V%knVk(o@5ck2gDW6FfniB|~62rK`#MIMxqa<*jlB*;xUyG%jZTv0Boi|{- zjiS!iNw;CN2;w0mcr5KglK`PG4cAqpmBN@{B}K?fVmt~w3$z3)JP1l7&U}!VeCQ(% zeIm+QEff|VktEnrOiV5g@+caoJ+Hte1WqA5K^v_Vt{rt@q8#`J-r9zxAex8_rxNKZ z-UB^3~uS(vW8& z_S*B#JAH0&etz&hR;rsC(1$uGTjA_3j=iPz4WeYlf- zkCicVlGv4JEQfJE;zxO$2VemM=GB31fVoY4l4cDX0$N$aO%P(x4QO~SYe+Y6dZk|A zy+Jo=GBxPH)I^VgmIYQc-+P)3Ot5f>{T-Z3#QR3`vBk&T?o+vF|E%pkCOub%UrV36 z&$rd>-lM^Yh3z3XlAp*!im%TTl6Fb2gDw(=G3;Du;5H@vF5UZdBsB!PyT;b`wx-js z4-JeuTe)QNBiV+{?djW|dsQ|Yj=`NuA)7srZDf_9cru}T%9p5mp93e8zN|ZG+CWz@ zo^Qk%Jq_uoQSf9)Z)F=~n=QHVL9ovWamD_}Ilj=artzAg8lv_vHCx9%f$CEe1VQgb zoWgbrOl|py!j+hCG{KRVw1aM~H01Vm?mY1AR z7=hIe{M^zV8|#iW8aXKNeK+LeB&zQO0w8aGCFtIm%WZTAFW#uQ$2a5OcxZDdLGRJe zhw<82_YhvoHw53}2x!ZL=RAn1#f ztw$Xbo+uEJfY0d;N^(I@rr|i&@AGB~M+&-@PWwj_88|xidwljW=p%y{hU0QX$qXIx zjoZOlkJ(ddP|^He7o=P<6RjSnD#z(BSJd}v5y{nb#&7@v**|HdZDR@GHem?Yhs)NI zW3?x2>(fAJih9$&QZfzwXsi&K!cI>C?ukcji453D0e`?zrfLyr@H{d(tf7R1Yz5hQ zoX+K>M~8KhPPmvQCQb&NP&IKj5J<4OLc(|)%_h_afT)Gpp>>x}Ou%eeUw<^6jCuw@ z%#1ZKLdVN>x5vMxl1w%CZB@&1H~vj`y__g(i+Sr?eJRE>wTFl_B&m^FE0#@_CB6AeG?hBIqTpf(aV@?Ag=@_qpNRbM#14cp%f1!W6*seVLoCGYZ#A6BNYb%h z!@2N!J+k;MNFlH(kNW1&-n}7pP7MYRUVH7qU=T@8zq8cYm)I7L>H9&y8iSn>OO|+0 zn9o-5QI_Vm%IOuR0USKTG3@1OcK77y=;X-alQ;iWIh`(N_BZmX^cqQhWO7)Q-Y98b z=@vElt&;7tBagzd!m*7Tk8NTe+%0$CyAsJY^5bE(mHu8zc83#;L0Q(}K6Yu7O)ynj5G9QcdExP2cx zeXH_&R_Ed!xyg8$wJwXXDT)1|99ccK#wxqmeEj0^REp0}&~D#>Gu0Hw%ZMa9NE`<9 zxWuO^7C<6v)4_@AO*=&zPR-FI<}4oI0?queMT z3zfW2(C1K z8l{~Qd@v%gqWSV9B@QAhejt>UR@viG>4pbyV3C24&oi+jH)lZdGMbHU8Q9hU_db;P zV_I^s?84Mupcoh+pUBZ_{T{3^{y@zCH+>KopV+kv^Z-v^Xuz3c$3tR{o7#6<6e#f=g3q6c|r}ABp6^F3^i%o zVpSyTG(d&1o1)QtEk1ejSMTYT3Rql5?VC^Uzi1+2=@r%vq1MoYoVAw+&Nw#Z5gZ$e^z$ts! zFdnukk9=5CeV(}LtGS|Kzk8eH*Tb^x^}|pnWPh!&{0>*;FbBU2w$AssePe+km)q`T z(ESAOOp-xwfF?6>d|VpDjhW&1%5wOvaen~v@G%i#YS5m7d3^@+I&Qhz+m5il&d zBmtck`E1tCoj#V1B{;8unMwcoGC;%(I{#3ong8jrdHNyzioMCcz8H^q z{M%1h-Rq0VnA^Mk#KlgSb8`6tA-L>@1v!V)AA!=nW`&bAaGgQ{Uo0Jr!X}FW?S%oW z)8%qS+;G#S;aIIg3k75df8S6#61^u9Ev|RUC$_tYox9$PRJh}f`dv;Pd z^b>lvZilRR47=e(>)CX#2Y9s8z)^-NE(3f|#cIrLooLE4Un|c}0f~$_}|V+{lwu0P?|;8qjY1 z4dzE+Jcm&5Jl@R^(dy5pWU1d~go}nf5${jggYtUWX@_MkB2p1Co5)p=cmn!I=qK)A zC0vZyH$@Dhs(~U?D#@WgAFwepVA=Y;KB>fTqEc6c6a`@#B zMKdv7hIYdYc+V&SOp^y>zu^IJh}xk9^l=8V7>H)%HUu93Q$a*rpXH9HRAzni#ZPn0*Zah1De&*#v-%I7N#Vb=BjC9HC}U zud4R<;p{9+y5Frz_OU2T6oA_;LlhPZG6dtSt=x_PT%s}chtM;EmkdpDILme{P)I?7 z7Uuj$Xm&{oD1>+s_Hmtc7=A#*fl!D8HiVqw@rj^2lJSz~5%N_|_=LHSlU`5VdAp#}5~C@|F#*cx7)P51f7S>9%Ewue*b z14mzWvIN=Pl+7`{voz#ZRA+8z;~Lma@au~1-hHrA^@7|!Qr@>kzS5?_t;dkv@CA~< z0QQW}#bf?quPZdMefND1Ef0dHQ?aL{j#C?Ts!k~I=cP%=F_c}Z+oL!O(zk35YtRk` z75ew3r`i1=?Y*8>IrOYbGl%-pT$^}DV%AZe=|9n9sF!KKMJ{lt8~gz_V)~EM2euyG z?e&^?1v5BEr$5}q{L44Tn^^qJ?55-Z+7XV+p-&d+mIk8OA5xQcUm&JHFoN(LZwM4( z><1xtQT1DO&ssY;=R=+lZ0F>?b{WDFdVe4EmPtvXXvk937OV8Z86lh`1R^f-NRY(3 zFR772)DOZ9%!NY(+87wSDwCMj)pTDT0;q~+xYCh99a3CU+&db=tOEvv*`gY`j^dXF zv3W4bXDA^p4eC(B<-#%FGbmcCq*H^8(oz4P%#qehW$NfvTcWJP3OKQXrZ?wAsVIPA~o>C51lv zQR_#o_ZjyaxBBn$Hxq~YU)`7ObKLpKPu>~MX4mJuAY+uWw+>vCoD7`_-To2vBY=tV zZQ0KLomByoyko3|oj>T|nCB91Un66p8)L%C5w^AgQv7O;FIn)(amje}F#3Kimeo86 zcUTNC`LVrWCIIJR-wY-~p+o^@RQuLT{eEBE`l!o6;^}5e8QIT;Ef;6W1)9|gxguN0 z;WM6BAYx>|Env0IbXWU|_U9fqz4xu`!!d^te|+i=1LtO&aV zFm`r$uXl{mK69NMHZZAFipvQgkA6s4rKv+CdOhFjT$aS@k-$s@d6d zdUbUm9*fIR+6_$(WHJLk%6yJQDkdNd8ykgO2`#Z?D$Q<<#CBh2o+Ew^eB&<5RTu}D zg@g@Yj&RZlQC%RrN@SP>n%*Rs(7ZDjB5HrWx|&lF)#B5b?h1Acx`}2d-Zv+>rt%MS zyt4WE)oz;-aOgq92C+PdrZ68|+1M2q`0hXkU?bZGVj5^80S9EdLP{hMklj(|mrnHKGk<(pDctufP(BJ`i@)a5*CnMjbdv*oj8# z@Vj6VBMrn)@&y8rt3j*kL=IR%6L3R{>1DK0KerTy#R#WUqDk@whY02p{h8xnD+v7m z6hZ@GOKP`=V6fX^_a>}XyTb{?p>F6Pop&JqYQY5(t`gf&n2GBSyP*y)1aw13Gs@U! zXg^J&pXbRYC2$}Uai@L6oJ5ES;U^?B6sF-vXeP!(gPrjQ-*CL!Qk|`0Yy<*kP{+yz zJQ-u^h%}bYhWo-gh|#O!Ze#Y2ERJ9U5n$!Te#sswguOcy2Yd}jRcF5&WjIGKaTC}5 zLb@^Saah?gR%nN#0RzD;B07OmHwZk+e1-))!5Z`v%!KQNoQV~kM(j#rGxGwuk?aGm zJQP((UIN5#P*s4(5Y~bP*5U9vhcQZI!(}I9Y=l(F(9@x@&=)VU>jUn^Z@baGY{VTn z4TGqXOOg7bI5^k?QJ^{!#O~rsLQ`Ab)}=@UC1L{??>IBYjPF z%I#`x-qcb99duVSfdkU&efw84NX*rLGKvk)Th7JC>_(jh^Bc-po8Fw+w%RSlfCZJy zvgVBKj7!#Ju$@!-T=yKfvXm_hu1S=S&w>R2We`Agmbiw z9}=;9qsUD%G^J{J_!R&jNefa}LZK$0x+QD?W8{Dcy~@5?SL>zfAUja67u&7wXrocz zzqd~-SEU3iMq(K$lC8-pX9PPq_Bv9jhuja76Mbq`EvY|!T>bjk@Y?mmDOF7kO|2Um zhVp}=r~4tDM;(O`-9G>!Oo-*d9v=(oE?Xqb=Q81D{{q?RcR}AS56aq3l9B-)!u=$G zLP19hDG$lnb+E6AZ42ZXx1^ zgh-CANH~$fc%mH^Lv4Of_Z%_v5#VvU*Q?sL0mZhHWT+i)6#Nd&>I?cDpM^_?NUGCL zMPPhSi9|PViAH8SvpP;B#>|vzo%4E+9NF&3JMee00jW}mnHsj&4(jXk4r{}@Ro9$; zj{|a0OM`I;2mvgv+$icB?6PV%4oqvZ)=p3!U2_e%APQ$ILH?~$*)aAi z&p}TZ5@~Wcus;AY2R0DeKVT9N`q0q!Z6-Lyi?)3hlTi4z zH-`fQw}NpB%W?434T>+-xIQU#J5Oe?>z_{xD49FCGbabpT$BN6NCtZK}i~X75GM)V0jE{ z(v%*@6>NG!s-XglsGz7-AbOvvfSm`=crYQ!b&K;n6Q%KoJlGBM{FCDivL;!9;dd1) z)HuG-tTcmM8<Z$J|Q1k?m5mXtR zOUe~EJW?6#(Ccfjrw0=3qA^>9Ma=tTq9(@<(|f)Up2E{9ijw@uS2-|D6J*XSw< zxZ_!wOp>xE_*=K*s~8(#MFY>SoT-p+9vuKReeK6Vjl(k-sIdWLmq6kP>S^myiU4`R1;Fbac`iE?R`~p4)-cFWzNUxeO5TbBmV3TmfPc79bb!I$bnlaQP7TUiy1H&K%& z_VEiV;s{Yiu6TJpmTSdQ;Cf)+cQHv+!;TG{IXn&zG_lWBeE9|53?QM>I7>rD^dPsv z0W0b39G8xB31m3+$O#jDpo^=ESHcE2d$*^y_z*h^3$ttoTYN@^9|0T}-HR`L_q&&o z-C6qXOV8qXaWB40T8Y5?@nNnyW?J}=@Xa(_wr9Mo=<(naG#V4{kHv2I4!hU0cqMGC zuy?D*;+)d~7ZuwVq3KAt*%Rzp_DRq$OyB71XkI|j9SZ_nHLW3O>`WR{3p-MM9C!sV zE)AkpgP8;g4==e}8F<3KbLY!P<|KN1yl_MKt8xJdkPUoO<7|A2b6GN-4QDsA| zwn2$nSG92!vu>)@HX&Ly^h9jqQEMLWS&t&~a`N7o(i*O9`Yq)gZVm9Ojf?-RY{V7H z&gmi+Zi|%kzsa6-M)2`4sh1?bmh6u%T{pndy>q_PneWbVaSJ!MG-{eyIkKJAI`r%{ zc@n7j-U>S_{_Wdo#Q|Sv8~8$`vArHVuUTNT*MRzVyXD>3jXq}iwB?JIZ&CC0m zJ1r!9N`kL1a3vfuf@ogsk=V1sXk9|sK*_F?e^HvZxC5!qS5D_d2E3A~aS3Ac{gvqz zX1A6pXJ*E2W z89V;oXhzfLMTK?;PX5&zhOT{35;LcbcbFyZt!>f}N_;g1cX-Shd+& zDs0IIWG9qUoIs}~2`n%OtFz;FyVH(;_*wZkeBKp*l397{UcplAp5S{s~JFMgh$GvLljKwK=riUyy7y5G@th z4D(5>6v$$$g%xtLCA~?TwIP%Ag*k_d7sihj4ce593>I_HQ(;8!Kd}km+z%_#WBR|HfxhXIpAIkNs)!4`8&XGf zQh7IK0NJLYQZ0K9A(d%yha3I?0!32u{5jWbR(J-wV?H-uc;#!npkXf)U!eS47y7(A zq#S)N2W6NNen~!MIwbi#IURw8uf<_%Y!dy-*?-D)fL^%ubbg6qPnb;!#67<-cRR>iZ;r8{S& zG%hkgjhwn`n@7pJUC~h7?i&~!O5*Gj?uTwCcRrAjsJP;>&{0j!r*-CQHW?5D7=Fp8ZD zPF8aG?sBbVkW0qXd^tz0X^-Mng&B%4776M+jy?(+rV3g;-=au5tq$6gK)u)-K?gCk z#TS6S>ziQ-2Wmup;an=5l(E$upJKE4&cKiu{$?C%#_0-%LWU=v&Gk7PVPDkY7IW=07`HLY4p0rCV`a`Q zLhnWYkT|&(L?8VZgL*Z*j+$ed8;epa>0tP6gYnha0}f;d<8ChqGw_)UlFQ;h&_GXN zpcfq&=vXVvfiBTNXU+nX(qE7GoCBK;ZG&AI4waHcFy*B5NZ%%NYMws>LZGghGXVT- zbM0_~XL&97SR2t};lPSgLnubVL>MF!1vD36q(Dpt$PIu4f3D_y!qRLZiTN=5Abi^{ zJ`49oR(0n<5DLOTMU0_Hd=%Q?j$m>dwyuU*S1D^qrKHp0jFFd_%}z2a<=jlp3UV$u zH35mv;ei6cV8UaBLNTW&t2Cm^b!A3uY`xl-7|HT}G3ycG)SQ)tTbefi#SmMrSoprx zD>^|B+I~S@fU4N3A{bI54N-~D_br!$w|Tg4C~0dd?xi}o6{FI0;pcn` zx(9aRQktiRRGRG9a*KSBd*&D?SFpq+%{d&4zvk9T9E;y^I1W2DI#>`c9&pRz*zL$T zA-?Q^V-c~YLRRDxkQJFjPtsZ`wBWEyVRVAR$X6I~W!~ezSU=#Ni5?SsnIcI3V^c#; za_|ZKiQ~US#vWzt6Y54ahQMsQZF%jmA&m!ZQW+Yu8)QY5H-HIIVYc9?-K}JFD-6Hb zq$;!8(jeuhz+He|Ei{Qd1x+jHlJx)($2~Yx->4`zqW{S(xMbVnSEWe|(~GQDII^%# zf?C4QTQ9OLXtxqD8~BjnWubEsnb&}}46t;55=z%6u=9~MKD1*KI2WcNbZ9^)O(C!? z#;8(G*PPDxIi0n1MHw-SVb|Y+=rU|9{xr(MQ8s<6k*V3HVzDV(Eo0ou^ek+*;Ov%t z(-HimcBTz10ouhOoN|h2X~Op4dNEZuX%~4@?9T*E(&yNB3HhVN@B*sDuIoUy38;Fm zo8$2spm%5nP#%11>vwT{@Ez&F!Sp*&KwZ5HV#}N;y?n+Bk|fEJ1nSa>%JiyE6O|k9 zz|@3)D;ia#_efT22qyq-g~mj^LO!H{_?af<%wyNJl}`CRxABNHym%_D>#bEjI1TR^j-FK_5iTd0I<^n zY@^HoKRpDAu$$<71}nKh$<;x!&Jmsf1wkFuC|M&49uf3luo1LGa2CSgF_=j_Zk|g6 zFUxcHjOYg7_+jCKkrV(xLh_w^R9k+Q5f4`z0fSYbQ=Nr5NEkCn$j87jaIp@li+9<@ zdcdd}0Xu){qb$ex1OD?Qd^?(M9TVG34~`|cbaa=VBA<_my_1O=TYkXk$rzgjxQabs zOuJ>PtLuU=xa@Yy_^`|B``UTWC_{zc=RcdtDJ1s?8Gnm=h#Wtb;0e-QVh5KV)bN0N zgft%zj)V1veCZL6!^a>YTC~PUrUgHZSfF7`p7fkffB(j6Wdk#61`Occ*!hl4 zc}%f6A9FS;)7`RU7y+17#zZvdg9947ryzL&Yz~}EI!(h76BIIV3R|Mp5tc$-w_;f$ znlH>Tu-{LQdlc;qt8T2aBR0jizGQcdY$|WN9LoVrLlmqu2Bj)wj=+|w=3)^oTdiho ziEMR)yk^}GAd9%(YK6wXw1Kconx7WzX*Yo`Gq$qUbmHg7umrT&foBb(Y*Ya3W-E%t z&Tylvchc{r0Y!rVh^F{Ih*e64awOY?q9_?{o%RK{aVObq#g8`_jRw6tAcJs7#-CN5 z)wEfT5BV(juoFu%DSm$3T55by#pyUytCAo;aenU6)f=E9ZP)fdvZ_|L$C&XPd|W^0 zf?s&1Z=0NS*|{Db@hv9cyL|(sUAV;}EbB{E!y?lRvZT{^-f;4t*WK2j)DP*WKJioD zH25i5e!+Hw^J?*XGtgLtr<`RYt>*do7i6}_x^MMnn{D$DWR4+3x^eM&+^eMFwJkg; z8Jyl@V-Gn00SwEOh;qPSLx7ni*Srr+>z z@l%|d2}x=lpRgIp*}>s*njM|EubUgcZUk0%Y!HbsirXfmlCed3PlaI(pvrv_?}H4= zw%~nGM0r0tK|{P2bo5o6%TEfK73c@zKuEO>Hu5k&bgp(>UsF88Bf;9hS_@;Qpgg=% zi?b6mGaxKOE)>iKy~&!(RVs{=#TSy2nzHwUz#DN21vhf+}!-b zCN>fjA0ITjBd;C7n^Y;iZ(AJS19nMGqAzvnaa(u|jVn(075j?=JYu44Ca_-TNycJn zr@`?A6(&&%s04EeG0~_R6N%u4e8&J@e#TG_q zG_IprtNO=bk0Kp5S2&su8Cr$t)PXZFVlX`5dk?HBYpKf4?u>KjMr#)wUNeL)I5>1DBE5r0N7^2k-N>3Oc}l3?1Md z9BU&afrwX}f=>H43WpUFi98qsbOR$Uk6$chn5Zym!>8*2mtqH!K?1!rwGg|JglIq2 zAKM(e+c4@@ds?$4$sFOZCjjxJqAn>x&k&3f%Sqz@Ds^O1AU8FQ*J;+%U!!BPG+_RemGK%u_AJA=^=$tO-%q&^TmK^PS6Zs-DH)9^N5lJHxibF)6HHA94wYLzG|Ab(IIgKey8 zl`~dr)w9BT-yOImGOTz7nX32*UU@smxo+cg3yp*_+ClR?X-SH*ohuqI*?9$HM_{f4 z61?;C)c+ls5^~3;&Clb$#v@php_^SZmrd^4Z1fbAsCj_m@L=}@w!UX@QPXf9#ApTb z9Xyx90RiN~bDK$>Z!2Wpvr>b;1?;C#OOXxVAS_Pr+pMaWU522HsRvc{Ai~DI;HXV7 zx!aY&^@7aHmYbocm;#nu27PA?aY_NL>}Kr7Cr;oo$_4uC3O~5e7USy_jhs5>`vsnG zIT4-8%u5Qxqx?){9v8SAsw1ZyT%T!UI>`8R~;kp_)|g5@d1I>K951R9lp zjPQ1ZHz1JT^V>yC-^X{@KOlS?;mnHg1k&`J!s`$|h;RwQG{T2PnyxPl+i>r5D9hg? z28Ery5#e7Eh|72t!YKrjANohc&{kr9Antt>@lrs4u`3Y%6yf&~UXMU|-+?fN@IHhE zgaX1+JENRraRl^g3;QVo)s^~#%0qcSf$$N8ts>C(4qK{rClep5KZ70(VLP35P&E5G}FaqlqVKM`rl^Cgj{?^AvXR3B=~+fWATGm5GF^o+{93*q0z zH9e>AEXCKD_i3InswX{*ikR{|h;NM}ZXv8jKTx3htU-7df!co?0<{&v#5lsY6P+rFfa=-2BH>OV7vjLpVP_K^L{kT!eRX>*pH*SH+6D_sw`o^c;=ztR1$XSe4T z&;6dKA&Ok^?)2W~ecI>pz0LQGzu@2Nf7t)az);{w&ZHaFT7z6hW z{5ZKb`L^V5Q^!*GrM?L@s`>O6Gbb|-WM0Vb&)%MWGMC70%pJ^qBlkjnD8D~{Q~nVg zr0y7edMGw@^UyQH8;9RJk{{`fj*MP6df(_%g>vC!;j4ugiffDSEsWbg>)3T;-!Bi9=gaq$pRM%4rS|J8zp1{ydT;fq+M(LxelLqVQuz-$uCYmzvgXg9$oYEwSl!) zuKmWkp>%p1 zdU*F|cK>G2|I9_MizY96@S>m3mS)e)&CFdt_t*jJ zf%1W!2TmRM>BR>xe(;jeCHG$P<4eacz4FpeA5;&n!w6#dgSITm4B#J44U6Rj{pc8R z{GZG6@#Xz)qvf34(tT#lz?z2 zf|+KZfPGJ-B}kb5R-|QEC-922)e^v*H}flya{q`(tGNG^rDHh>`ymUk1alZOA_*$m z4fx#*TG~lmFQ8^gQ1eei|KS?=W1ze@fDfF6_0i*a=NM8m$a?~5iceaOB1aN*)e>;; zBrxz}cybEwt^)mJ%yLBJrP$0{!q<)<_X)griY)ebP99!3b@+BQkv z_|g)v%TfGm@$sukiG%W8e)`%|S0lZR*ZDZFon_nMD~_MWO{&K4s?I7@>6N~kMD?iB zH4t%I2vtJ!Owxl$^Z%eeF3eiNg}9KDv89wWJ9H^xZ3vC3fbk=5a~wh3zZ1X~62;UviJB%Z$>JdQR5y}E3g&9Dt@BMg>p2K|03 zU>C#c!KJXQbs4OeF0e!Fa!@W0m9R5oi&n(u_axp%X>;T7OL?7i%Lps4);dq3=P{SnUN_pv`= z9{?Zge)b{uVfGRB0Bm|c$o`aljQtt=ICv~Q==(nepC1piPq9bf|LxPTA^sWow)#u< zSL{*tIrbR)Jo^IsYxYI&%Ozt-cPb`v2Vlg z#CJhIeG2x0zR!NZo@W1>{gC~LJ;VNy{h0k9NQC_aoa5)%Ke2yi|HA&2{fzw^`#JQ_ zo@c*czhu8+FR)*;-?0B+|H=L@`z?EsEi&Nlbbf>YF^ua%te%W8k*=N{d^M*8xqa-N zUdTfFrGONK_mHp@k)l#eic5Xk=@Z9iD&?|>D2BN zzbfEY1^lXjUls7H0)AD%uL}6EyT#kDD&SWI{HlOo74WM9epSG)3iwq4zb4>As)m0L zCY{V!z^@7TFcD?m7w~HWeoery3HUVuzb4?<1pJzSUlZ_a0{*ywKQ7>p3-}OP z{BZ#v!rA710e@V;9~bb)1^jUVe_X&H7x2dg{BZ%lF5uS%{JMY-g-#BqF5uS%{JMY- z?IZKKfL|Bz>jHjVz^@DVbpgLF;MWEGhJfD?@EZa?j8F0JHw65KfZq`CVJgLZF5ou= z{Dy$v5bzrUenY@-2>1;FzbW811^lLf56hSQ`%MAADd58zzjjyCE&LN{FZ><67X9BeoMfg z5b!4i{0RYnLcpI8@FxWP2?2jXz@HHCCj|Tn0e?ckpAhgT1pEmBe?q{Y67Z)4{3!u{ zO2D5I@TUa)DFJ^u2jn= z{A$^RUoD&Pt7Q{@wQRz#mQDE8vI)OhHsM#xCj4sIgkLS2@T+ALezk1Eua*UTvHw@a z{$CaQe^u=NRk8n9#r|Iv`#+=w&GL%a*6E99Q<+r!%xto^bLVWTw|*|3?6oM>nwv}ZjOm3ddP8(+OecF~ zN|Y(bV>@S)N0MjGEFjCy*?HVa@=TO!P^vK>pP!qXi}x&}b90%VW#{bSxw&FbDkSk8 zYi*gZF!nZvX7duH(eA!kwt0>bww$Ls1^a8$@O!oB7W@-W?GVQsZL07wRW#FpVGYZL1TP=s^=W+n* z**o*eGxN!w9px?d?1e3RXU{@db}rj<9?o1}>^TZscFk_tW8RFXaNp1GI}2wmj?TW> zv+&3S@a>*4I@hywdQz@^R;M2WKRp&gBgna(vu7Dv23^rUgLVa2eI%8^YfI_4`J7&n za{TEWs<8ou-!PB%JJ)1q!C}v!>Ybit?L*-H@#c1+EXwrWSxe86X(#9L-A_543=(1O z_L=#!PGz)r)o478%Da)#HCpU>3TGL`-ojalVqf8`OtHUk)=F^ztx9pQa8{)_R5+_q z94?%-Q5-3p)hUh^dbZL3A?z4nNAXS^uqo~XY>N8#XRELnm_NlOUCN&M@s z&9u(K2o6eBKpjwmrCjqEKnty6uUIIBCyTw(D?CNdUydAOXgo_OmnTahH=Q}N zA+rH9XZ8^4&|{d(CD=a-07|(4*cf~G<5_y@^yuL;rA#t8c?RFAoO_%sncwJHX`z@N zP4?z#9rvL#90xr-dqdf(Es?fW5Zvk0y z{OkC|;up`P=FWW)y;r6BBmqOoi~3|HQOz2^-LqkaB$G24wA&~KL9sW^tB;aNqIE2L zXG_UREYnmjaT6a~(R?{vZNeiAwCT$;W{aCET1K=g%2e#t1;ox$v(D3=fLbiIe4~&_ zmZ0M!`;oKZ|8KBR>(E@C z%(UXE6&;tF6D3(gRbFbkwN%R#wJ#M!lyrk)(7c;OVg?CDi4BE^7{9X-34Ui2 z~C=Vs}QXWd| zqdaSo*iU&VaS`RA#4P2Z#2n>Wg~S2MLy3zi4<#<4Je0V!(5o&t^Fg}kHE{bfo@ydB z&qobzw{Wpg=+%~UAEFDM`*NP5+*j}vWj$QzjW1_CLKi&iQJ$i#$9Rge9xwFj%UNGV z7d-2$d5W@L$y1c|s={c`cDN^JcV17+cMlUEoLR$V0}W_?dgiI;2nU?w(ay q_iUEkzH7F({`T3ks@%ok#1)VXx&%6bf1hSA-P*Ih{j6f?TK*sXH|$ve literal 0 HcmV?d00001 diff --git a/tests/android/app/src/main/assets/fonts/Ionicons.ttf b/tests/android/app/src/main/assets/fonts/Ionicons.ttf new file mode 100644 index 0000000000000000000000000000000000000000..307ad889aa8ed924001abc023b3b172804b5e657 GIT binary patch literal 143936 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 Kj_>Q2Zu>vsTUp2e literal 0 HcmV?d00001 diff --git a/tests/android/app/src/main/assets/fonts/Zocial.ttf b/tests/android/app/src/main/assets/fonts/Zocial.ttf new file mode 100644 index 0000000000000000000000000000000000000000..e4ae46c6286b2d6c6676b0c3192fc92876778498 GIT binary patch literal 25552 zcmdtLcf4Fzc`m%y?!C9^edg3TXZmS6=cpY?KC+r6OR{XqvaDv~f*at_O^oA!LouN{ z#7PJx#S{Y}ARLk#OfDgiFAx$)E+O3Cm+(RIkxL2*Idh-2XJnj9?(cWMf4?)D*?q6Q z*Lv4mp7&Wx3}G0?U|z{^%%P2qqu1X1&4(^9%(;(ZZ}#AIbL~UoO@F{JJ{v+q|IP?s| zocQLY^Jj16e)zeU;Mh0t?O(zU{zW8%d->R|Ub^GH7Yjc-#BuToZ2$QS?mBn&7IkwT z_x~=o|M-rxFTR_(LIya#fbHU)XYV+F-`oH60K?q$9_;(ayYIU9zU|T*{+40RybWc# z41G6z|KVqb)){N%9~q6s4u<*i!JTKXE{E?KKE=L^Rk1BIqr=HHtU7#(X|fECpJ(5d z+=*Ut^-oClTp}VvpBxo}FG=>TGtFcVPkuz+zzEpApP)vWJ>%s+GAZUY^a26(H2x#@ z)io>+UD$mq+N1dWTgfxSXYdRva|pZXyIlP%V(YgVC)xY}exDsZ!0@|_%^V(nc=!#b z!BmI;oE%?briXvcFvCBgTf=WLb^QJ-Q)F&Uj#ii{W}5lb@RQj4Pt45lkFoqRa}%!q zCbNz+b}&a66U(0-z86Q(3d2tge`mNg{I6L1*6;(v?+!mV{NC`>$-S0Q;==H2SU-x_ zi-%vrS|d5a48M+LfB63nKg8@GewaCmD{{lH4xh#6JHy|>F>&}F#$|TVr%V25-Oz7# z{NDSqMQb3-@C@VuZ8d7G;`hVv-wK&yP+!dV3OSb#?Rqr^}?DqP0h#$H^_^2b{}2#UJ56Ao#+2g&&BYm0lx#Np8xolRvENRc=(C zQNE+zpuSF<(jM2osL$)S>7O-TV?1fr&6~}anopSDvTn2r)rfPo)1fvm^7m%r9sC?00fZ?v=T(=KcI? z{?WpHgW3Pu6EB$LCtp4Jqp5J} z;i>mb@0v-^+>N$klYa1aatsn8G0hJVW^U!f63=|E{UK5K#>$5|7OTvMIJ#S)yFV<6 z(ss5ivGk5VrVAxijdvW+^updm(Kr#(WoJ+o(?yytjyV#csT5ryb?_Aj}az zjPSwx;#E-*^+uD7-nu^U@wWX=AE)=a+eldwqvUoS6c^DelgdHW(BqAI1t&=5`e5GY zgqOeN+*wu-SV@r-bLRHW!PhNtZ?ELC6GlPOLf(maR$fwwylYlpDhi6gvqa`Nh2y7q zQI>Hbr?T0Mn`*R=`!*|*KoiBBHTx%oHFVDvgiv5Thhquhh^nwcq-chQ%@v;CS0gM- zI9-tBbav2YIr64T%g_bF$tBHVU0Y=(eAwA(E-&bcBWfD^pcx3fCh$C0 zD${0Gm}{8pm>Zc(41;!nXeBjQu1CF6;EU6wj0Wkq!=T|u16qmRbLXHDdv4MOy>9&{ z_qY3W_aMSu%V-HNxeaZVa^3L^({(f6NmBES|8Ba+Uv&H*QgWIlyzE(qN57mVE4pr< z_RZ0Dq}#gYh;mBOMd<~&*2{RWe-y_I`cwbvSMmFA%lr2)KgrJWO|o^ybUot|{UN_@ z>$)uKTfg}eyGr~l5j?}#`oeQ}VnkTBr^qwpw^28bFz;bL%3NW-fV$~IPN{67hN6-1 zVy!?Rao91E&#|1MTT(fNd{Q|ai9QuT`k_LIt{g5CT!h}7eCUoGk?0BKY2u^W=`CpY z82rTL;{Wch$$r{=c$}*xc_DfPZi;82UE{f4aM;q*it9PD9&5U81huZrbDc?F*L5w* z8D@XsSgDwg(}s!1HG^!vwqtgNV`XD{SsB%D)Q1(8CDIh;P6AkXV|^u8D<}RlN*^A zLHBi6St=k=o`VjfDh^!=?bGedw_9kdL^n|d-k67gtr7@Eoa-ndYAH28XJ_KTvt(Hmb!b)yD3mPU zR^~E^BIQse0y)B`ryW7&lz}7*nevovrEO2(6_w+NzO?s9X=d68(^fV%3`NlmQB*Zv z=ZI(4cH~mVYo8oUR%Dh4l3}Q-B*(IB$g-j+V*CbH(}+kEO%)~G;J)cD)@9aVWyPwL zQaZ;OW+cm&BNCEtXQWht6z{t1t11f%z?%k?zAdso&mAeAR0Pwdb;vY^e?q=Vz5-u+ z89IyBVWJVJUZ8#jG)+=>ScMQmoWu&PE~;zj7xg%{w3P|o^OthLs%?tT>91M=-$btsi`H=&j&%C+*z2OE{I=`XJ+C*+4?pMeG$Tzv$CtRG9jx$ zss!O7N1<+X!*zazUO9Cv8wA+^I^drm$0~W2(U@(BsLnx_SJ^ykvQ7AJXa*@7pbhYg z#~t(=^gC!s@M`c|pCeKfS}+dXa!V5DNHl2Y1T|kC1?$SJk%V!=+epghUH1T-!ca9H&W+;_s{5feBzRfK5b7~&iuSdu= za6W=nsC`K_;8gM)DvUd|0PTQ%f~<%lv@u5zsV08!Gh_>TvH(d%oDKEWUnZ!QJX~1X z*c`ej^*#DNHI-;qy79dAGdo{c+O+XdP;2O0inPQ_aMH->9iQBJ=BHibW01em&q=y= z(m4C+ooD!VnaHdps)k&JPs_oTduYd*Ge^>{n|6OS`5pV@l%DgPf>Z9v9!CIuTKqY__gTmSXa{1fM%72;qs4vlK^HUdv_DSr5$_kr~5u^$0goB4gSxMEYI<>ld@$# z3)ew*bk$Jccd!}g7LM>NZz{SY^K)B|?-~D9>-FY=@!z`V`(Au?>w4ewd~WafuTEZX zA?koan$U#tm$&lr3l5&$QhY;&|$B|U6jI)Iv;+t)-(?O+b z;AAD8Zg0nPiNJ~enk|x-L#I@k8K5^^NC?AG#nQ&3l@dpt#?#4jmCDeyh+qn&vqqS) z$?!Tsr8DSAS4{})+lv()Ve?5&v;`Puvcl=o)?dj6JGh`4SBn2iYFl5;HZqxpaBTBl za-Gr5HnQ0U!9hjtpcSa>^PiU$RsN=N_!az5ZT({%$1}`uZf@>rdMZH41SuMRh76$( z`;ch{krI_j*a}!h*8h$IIyv7~*|+ zyZuho#ls~I2i|~&GL=%3%=9-rd^|AC#;d+u1$#;$z%3 zz}y)4&kX7z1?_u)xlHSVI&X;wJ$6kf;sI%TejGFkZAQ@*P=Ha8CZSs34I{RK-$4CE zv^J^usLuPBa?1f@Rxwe(B^)wUJw0&DR@~)i9_zaL8wULk}!ZQ>SXx>6(MMV;0d?vL^^A zx`?_GP*)U>Vgje+c=#gbC(Jq_TSI1;{K~_>8vYOTiw*cA9+P1zOp93r)^rf9)$1+; z8d)ZeUujTnhU$vwc7W~iGTC+zc_imPcNV>{GP-n{f;GvtdGQ9RE#6oW%hG*fJNcx= z$E7!mrzXpQtL~R>IE#(P7w8FtE7A^W>xa^mber_}73qrf?TS>9zI{d7+LEeLithfX zlu9=5#5(OG_2KWpSG$8Od-z>G#%4A2V6|xVGZ?Jp!Zy(w=e_VIX zEGu?Mw7VJX-TLRIb^M5W9og61$j!Fjn@!F*Bg<#bU%z$vV+RXGl))6oK75H;g)M#o#Y$E=+H1!jY7{7# zM|D9HksIxhP;b~t9pI$R0L(Q>#Y_$kR=Hk1>Eu9#)`bm%PJgH4mhbGi8g{XQ+`WzeX?o_1dtmiijp%qtILrj8nwwCwKESc zUa(4*md}#~q8h1+m7XWr9GQKICfz}1;irQbXerwJ$mUz|4@C!2M zN|wjN;>&R*Z>pSGV4;>&p3fi>5(F2RhUnO?qI+=H*jdk3W?EvyRfQC1dj(2)?4gXQMitnZf%$0wm3W#Fg-7 zP8Ska_xhbuJF=)BKt)ijl*%>4n~o18<^AttLxkG@Md05b&di4Id;gB@9{|p>%#*cW zW!X)56UrN&l*lT}zQL_l-DjWd^`2xu{suwV`W7#ab)g7dxXkQ?&2XUROBBeY^3r6X z6X2>>f@xYyQXmNffGY6Z6GVYR$n6Lk4<5l)KVYUr&R6H_UWN$1r4*~qS~o%*Q-cG* z5_2*#`d^|LEs;8xclbx6Qhadhv0{y!)l5w@9dcu-U9aXPjt6KQ0~X^6z^B|%RWv6v zF(iRCBt)Wtl|9%ZEqV#f3KFI=e1?33{0;*kDMX{Yh##oyLTw*KjU)t*$r5Ij)?K~I z@!~3gi){X-xr07%7spC}G4;_UyBi1j2;I8_Od-GJ@hq9dytc_sA*B%;qL1+uNJX zD4w7Bnq>iw3vAo64I_|kM^iN|6<4dx+m~1Fc@`1N%v3t_JA?W8a@qBY`F5)_pPeq2 zZATO|-OwXhQ#~gN5n~y_d8+KZBSTu8mOjfwj`a1vMYpY-uHMz%erklga`mUFeTHB70p|y ztFbN_CIpB=h=kJ!FUTSSG6eB<-uAp%I|FxEG=M5@uNtBPsEOroBFI?GI|fUNni07L zVoNe9`#@L)1n*iwM@Qs{EJuiN#ccLaGZ&gCroxPk?v}MUSJ@UVXMR3#Hpq>fYHCvm!G0d;k7=T6XadOTrxKZY2HpfR1|9f% za2Vi|B6tcaL8bTU0~@Ua2W0)0Th9IZEv??>Esoy4<$K?w*K)((VoK~fa%el@f1H6e zf)yBnowxzqI+pZQ>y;mqBM@8E)uv6;l+}!q^ zob5ma%K06w)i6Epntsu@96K8ZIfQ)1$lw1o`7ZfgCSWG1??&~N$ydtMjWQ92O4R6~ zLfidqWZ=MX9zRJ^+lQO&>3z*b6+UD)oTyy)EHgDV9yzK>abu-zqiT0iu z_c0C5>C||1Hl(hSo zhgaAM@)>v`C1i$^I050!0A2_6M1YJX4H?yXq(S>%Sq!fRG;;?BGrP^w;cxzo`^hH< z*LpkW9Q%c2X6tKBb?51wsm`8GXU|{s_qQ6Q1K<9m%ihyZkj-9moxk^1dl zzQRg21(E^TRr1;TV$M-y*2+yriwk>aCK~xH(j|5--dl=N$a{s8C$=`p(@#y#JoWB(Pks2q54^ibz5r|6 z;n-c1_1BcD=kI^jk+;A7s}KAOsug;`81#;CcU}-6^G8n5$Zj zq2|IQ8$7OC%HKWMy&zNK{UyK5upSG-8pDL82to zEBaI97^D_i#OVoA3*JtRFhlg6-IxA??B2cmfd}@IA8l=I?OJ&y*NxlSxr_Hpqx9wNGTUjZO;U>?sgsR|A)HUyX*Ag zN>X>IJvgSQJ%G1@?=?5dsJlW%?QE-(@`d!pi|OYouhra0E1kl8)pQLduZGRa^D0k( zwM(iG2^FNC+y6eXOa_M+*nT&4@gn}=y;)`*{qR}Da#L6H&eZG3vw%A!sYAOM)!~Wd zg?;JaB?mChiK~W#G^&T*Pr4r!vI;fixCVy2i8wW}9ds8p3T5|1=cUe#R-4+ z4WI1I+!u#xP)~`vp%|jcnMh;5s$Q7aB{{RoiEL#v+~-dkfm)u5q-jop?V4)3F3m0Pc!;mWyk7=z9g+N z%6ND#<^Z}j)o-~hR>oT}#o4_!@9Ob7~ZDBhGF%0h9Aai8+d*l=3Q|O`8(o6zR0|w}oIH}># zzJPC~R|yKF*RcrjzXDKeKp%q!J%B?|4}mZ}N9r|_vpc~Na-sajH$?%eQq$idwA$RP zc;hMKm-r9zPp|r6H-=Le+V+mHNKS6OWon8%x+{uyh2iB#$dYMRc4sn=G-rQ4ie_hL zcg69pN}9ywU9%B%rinWH0c_D}VAijI&p(R#dM0NPWQ^7TK_C>SPy+DOJgN`rU3BX? zQid~|r)kkp3Q8inMbt*T-JvcnKB!w0&?{0WB2Z7NYiVoHq=PuUCw(r`IjLE6G zuH_dSc?sDV0az~5LosL|Tv&EpWJGhd0K5XiBh4WeC+5P?byYnmTFAi(ifpZ7vGvwHmt^=zFfoN*$gEJvV z*^vD3SB9Trm%+?@J@YHf2f@W;INT8$9vC*PQ=%my2T7`Fm4su7sh6n)m{8;ZLqiA= zI%E>U^+J;!T?w(E>8TJxWzuXD?v(6;M+CuY0=dV5ao|Ih4D<`$0q`2qu~b#V`>9ag z!Jq@riFW4!0s)|h)L`R*;EYR6BHeJ(F_Gv7s)AO6GBJ3UHO-VMN`|YZQ`xe^Df#?t zn3_(zJeUZorNnZ`ai*R2BH4GsMpHYVN-1IxD@vnRvU+K4(&H49s9=zIsYZIHVw&)! zg3!+fGav;86PZvDqeA2gwk6Kx8}+2|xX6^JerbtpK_ zuBfEvcvewQBT`2w1`t)|%$lM^Ien^R$`I!;7LCg8dOzAGgw`Rg7tL=)&j^$I*#{zUCFJ^mNv?9su+e<_e?IEeaLlTfe7cbqAM99#aO5;Ka*hP6xT&A=J}W!p^@nZNC4C;d(KX{FaE%bU;Ke|>`KyGNU9jbjwD}Z}LXsPW zLkK{{(IPQBBN&IgpUERdq$|8SSzS z20hHttUi54YUtpz)aTg5>lpbcpj`k6e&ER3&1rd2bBZxvMzp9PYq&O8YOfckqH&x!LaoQuUmor^c7K7GI zbFdT^vXQ9s0urpS?X<7C^K_2YNF&9|MmuR2$2v9W^mQmW0yTs{9r`0VgPu^MX{+brblkBAP7*aq z_)uK|Y;#n3xC?gC+eEbFmkzHngVSBq{Xpxp9^wc zMr3n-rc$x>_k~JIG2=?KO_RYTjOtaZOE^nciDH@%BE>PTmDJKpizz3wSu9p!EA5D^ z=7E7D$Jv~*oT{et6WF!jdfvn&xQoVonPMmZKKwHJ`xS6EZDs;abkd!vi-oG> zKrrs~yNync^w1zwJ&$WYN7!;U< zt*77eUVDy^!Tx<$KC~Izs`Fb(zx)Fx&(4!0%wb5%xB;nS5z_cQFU6rRIe3W2XM3DC_P)Tf>L~Aj!|ysRJM2Ac!hR zg(aDP^mMRU6YL9YywNcV+Kg9|8o@cibBeZR-e98jO}c>jf6T~hlYv%L7s@$~RYT*R zpM3z4;?F*?YZq{)l<{4BlSM|?U(-wfg06pXwdiU(o|ESEo?%n)9Th|j8F(@~(KJ9=#;a}v)>mkkY zQ&$pLD7M4IABFD;HJq2k*DmiDrPXqVW8cN8d|6=GcXAqEe%o?+{sMfubR3~m#Zf3y zM?klaP=+0i5NV9akzakW0P^H6meot}5j;U>ZBa7?jSFgo=k+3P$4<%*Un@!%9eAufs6<8yQV3s^oNpoEhtD_ zy!xbupoJ3(U<7lVP~2;aph-+QA>uNIQHJjy{u_IO%z-;_IN@(T1fT1_F+ZZLr3O@9 z!cjsE;salciZXDDGVlozhEDXQMwwO`)=+|;s-LwuJItpB2hH;caOJRp< zxdzQyCv@P^Wuw#R9(q=|Opfz-cP)@(LFO5psdZTLXgD z`#@N6GmukU*3nD}G^4;P=YVs=9HMzT1PT+ODrlsk3PKs+FT@q#+7rHrJPP403TUS< zQ34pUEP@IiJ*fGR5s*<;RjFR!Wjq|K8jAcck}w6<(i{dCQUn z!*C>yWbXo_zS}jngD;l~I0b={OtPX;%m^T6TPC~*nbOeZLW5-`5NnLNwLJWYv~Nft z-V3^=0gm@4@DP##J7jVgdm&rPR%k)UjX*6rrV8Dt;I+V46Lnd^4dD=~nj7I+Wz`2= zj$_Syj&stu5{Gmm5!u3t-~#h50x%v?5UiQ*dF8%rE47Fa?b@`^2rNUbBF9VpF(${x z%$I3~n}!}GeEq%TU3+sMx$U-(K+b=E_(^sVdB^J^<@bUq^>*e-=9A3ln6E<#!mdyO zhy8{nL6T%F?fn7rPreu+xf0S?2I;dr&5ls*K{t^Q85sh=zOH3K8MlZxp>RnLbr%n{QNFS0YderPB$n1Y|`cIw>)E2i% zlpFO_K%SgmgivV;#z?^B7QjeX>gpeU9twjEW+7K`Xyk$X(Y&2*(m@lDuD89jlg=)H zrjCY?M*Lt7v^rJ=6EsBP22zN`$*Zy-+aYKg|Mx#4^WBM=`Pt$?b49-pWJKauOEdG4 zmo-`BZ@sA5`pljx$@gE;=uJ$|&zAaEPYj-ao*RGMl$99$$1o6Ep!XoRb1&^SEK!P} z%NHz2Ivwg!q4dfS(!_H+-uT-6csGnYLTU*aTS6KEo{ob@2uxIxvi=k8*6hSubq{Hu zd%&;qq9B4Bq_V2K`NW&oxo+mpT7TR8wNnM2)Ny+!sD?9jAk>1KtLC(Az;BtM%;X0Adl1)6AxP8=7?70U z8zc@kl@`GnI9`v6$RGe?fwrMb($k&pv|;Aw3lZ&XyqE?`kXO|9p|+#I9i*thUiit^ z_=ERMX_ZJ7%EJoBIePo5H*hdNPC)m5CV@@wRa?X3wSEkT=v zg_kvu9tS}bzVfFK59}ppU}YmPXXZxsbz~hOoIS+VVUz?{(eu`??x%FDT_<00^5n}; zzKN`#Tq9)d@+R55ee=_4FPrt!ekSt<5OVPkKmVhY139Ra zotXHqA<5(rZ5fDh}Z`puTfaE5hgnjiD4Vje1dY) z4qZ9-SE>1iC0iGEoh}|0?=0Q4`+}v~RntDd`*d+CT!)Ou_Ifp*7T9HlJnPn%Cw3ot z+d}%S2RB;v>D?O#-$ojzS<8JHsir8?h~gc1rX&tU7TXyF(Ljo5GU3U0+`(yYeeN6x3|`=TPjDg!g}D3a5|tyjIjd$`x(|j8|`Lpfk$>fMuEHx+3JUpuYMck zC-EFcP65?`oi^TO&`WGC1!u|#&m~F;MvXL*FKVSit$o5*MEzh0NTNNHmWGy1_zkEI zT6xIkp`vJQ4rstdYbjbw?j@n5fi&nvR}+30G0fpG!L| zcayE^wvB`*)lIB8Pe>-MS*C94nwiQH1F(!8>hSQ8CU|&{J9}H0%1l(fvw6-EB8g3B zAef2*Au~=+>M*fFTJZ|J$eOC6PQ;zV1P7av)Cw&(7uHYTcR+PZoxe<{=h(gqcyymYze9#A@rnlh7M0L8Y+M_8CZMvAWE$Lp?9Vm^bo2>@)uONs ztgYX{C?0w`JVy$!C891-)z-v%QC8vhAYmeMd$uO$RX5Aditr3zG-}ne=Pw=KY2R*4 z6-ix@i-xFSOp^#&5(wD{?Z9e}vUx-nMoKiJ2uw!B_{DEzaW@RbfvW~x$qAN~mX)%6 z+fU8U_Oz&bwDYLBULXyOccOj>$|hhb#VOlu+P*D$G)_tJauoVrT0qJx(LJLag#%>0 zNAnak)dFf3edi{Il1LEb1oVevnQX6+sJkj)00Yi|BQVZ1C-D&BAOGUxJUM;l;WPYA zufB;t2DXFdnxW}xfVXDXXXC<5p)m9G-Us*Wd2lbx-0hD)emfAijdSNVh{W!=@x~pj zbk4~*hDhB)(ZK4;@#9a=mP)fFwChn|>+b`vC8lVS*NNa}CmIBODIxw!LB;8!Bjst1 zeWXobiH>%FpiEr9^JuoYSg0=AsNkg~PF<*W*VbCKMOf5Ntg^e#ADrKujdMV`KT95- zeazOYGY58T+uy7?l*hwCQvMD+o=1Q&CyYD5Z^$SBs_!*GDvyF1-KIhoRJi5o>?C>X zWNv18>-7h&eD9B5b-?}Lj#BewFKd=|eDIgvf8d{spMaLc`^1pbzk-}*QS(fH6jV?_ zo2T$oK=s6k5Ha$XFdCsp88C44X)ZlTZM(F3`r)NEd-G>Ulpr$-9{c!McAl^91ug=sBv1qD~*|>S!Kxj->t*HQy8Kjl>@lr2wvEfy`4J zA<>BRjR0prp(if{u&n~EhpslFU_#|bNCQ%(3HOi&CFo^|=7ay3SP=|c9WhFf4#7P} zeBVSLK7XVT?UJKLZ*_{rkllTet-cg4IP1pgaygyLvuBYr!>~UYk>#~nm=9ePe7(}j zgg*^3(>7;yfvsR)U~`yI$M#3o-H}vFpVTr5!JdD`_b^DHm$F=(B}ccZ&TPk65f-YF8T+=_l!I zHVl*%3`oEyele(3re6+o{EZG%@WJ!c4oG5p}P+ zo%f&?+*E2ugjl>-soskRE~jG*cAK)Gd29&RzQSqla(Vao5}9#fgb*uJQM`oO2fg@ zI*u1Ojvqu^v6Vp%VQR+?A{Em0dOA}BoewTB-uZ`k=M2WGFqH0t&N+T>2>r;^C+|m% zJLs{<>^AuXY|A4c2e8+KIGf0iQxii)y9u_Ccw}j!>_)e~UbK!ZRSHpX?lHl8ppi_GMtWRGoJ6YpC(PByR=*IH-Vf*EA2Fpj(%EvRnZHptDQ?**=P zJSFR3^lrUJLJ{Ll(3F6mbT_?uyRya?RjZQoB2SlMa(r`Rch3q<3S^AV z_}1oVbF#dBa@ot2GF~-jPZSm#gP>5#3PP>nJ+Z4$$mF8b!qz>vi+$5KRwP$xa1WmS z8*M^Q2UT}gzIw*OXnS{gY9d|MF~Cuci8+y_1yGy?hk+f+^S?*7J2C$%a@H*2B_r@PLE>|=w(Yc+JG^atX0I^nY01! zNhX8gSIT@VZFGTd?jpI~04NoPo@I?VmPAm_Q-&W0`HX|aRVE+AKG{KJX$K)6QIwAm zvaTrWcTUwX9v;T#n!ecF*%Y~a8@8U#>@$w9Ttv^S;7y)*zUL)T#USE0vHTrW?$XGm zNicbFgtwy}smQJov;xKADWQb!8uZcSk{z@w(vTx@&Ki}%iPqqBetP~W(rVp)qG}&LC|I7yP z><2bFH&yFXotfJChh!t4H)KOB7Nrx2v9nnq6%t=42!{-y#Yk>yY$hxGW}KVJ0KMvC zY{9eexkoH34^cQpyBY8_B#LR(C|3h)D~xG)?hA(l;V0(1nB4mQv(NIM=db9W)t`ud zJvv@_psG)oruTm3*FN|scTex1@uy!fHJEy$cB%fysb5ZiTlyUJb4AP^^l@MnS77_< z7@JCG$2d*1fpAe0#7hF@B1jBWlZU5LZ}c$)eU*ACtJK*ax%EhvA-gqpYG{m#CW5cx z;#A0Xld!N}s}wI2C3`-1;9w!dj2DWX%1}r~RlPWj)p%)Jm{q3tEU43aKCbl(`J8Gr z?G(aVJfG%11wW>OFQ$UUw5Da@@@rYe1HH)iqj*mF<(JN8gRmH{E~J89t%S}Y zh_a-c@bpy@NAK8Jq_DY~6#dl-Slr>i$=kg-OB>Cqab z27b_wFpUPJP!u4d)Cxc#sd1;8W0XTemM95UlS5;F0r#mNn#jgApj?hi1hUwx*L%JC zajucZ&aENxU12VuGRo~vsh%e92R8{!doSVo0N)3IfqI~y(P#v`ICX;IB13*qIfogRZ!ov*PRu!yqE0a=}jApI>bKr49hX{(5(T<74z>oxs59OSm zA=-gXj2S-Sz}@B&#F^mDM4_f(@`LLB>8Ul))U$zyQS=6;VPU<7?gCrl* zaoro>N0q@dgDpW^F=9AUivsb%Af~G#)2MGF$1s>bBkX(0OL)NmnWSFKWD4bM)&;!x zcl%V=>DOO<=%E?IkhJt+8{^Xz+xDE=M}VJy3cQb2B_ZLOVn zaN`ac;Zw>e`mCVronvixv0N!^+sivf|Jo@vnokLKBjZA8+3z9_{5@!< z{TSy=xpwGgktoqlLp`ohEud4uIzxJBA3{fo23LoV()LOu37U!~29s_Ewae8rb(sPT2My*(MJuULhZs+iki$5nTseBHz zA0aJ+e24C1P_hnY4;?a&T>ssys)$((?I_@3d6pB!P?lV0kedMxjNqnF%BhM$Ua>h? zQDa}3nptU-O30DB<#N50=8ek4{=vfCeT@ArEbImWIGYzG4RgxqmI?5uSJ92xtfKir zX?-mwdjs8&450a0UC&n?!!aTU>Q&9y<&=tXV}98;I5u=aq#?tvAdW3Ut`MSdtC(tm z)+)yM=V2D9iW&yZ93gMuG^f&$k43q!N-FO#OV}wAebRSaEMO=~ zUx5}y(wfDrD>g6H3Kf{pNMq-cD%UBqjg_JTGA67U4hi{#aeFHSr$YV!7>>MZF_}XhwiO2 zYha1r#k`#P4d!dqW2e$dC6e~^5Y04RMf*@so(5fTOwcA*<(P6V&@9v=K@*QH@N*(P zZnx)OK--Hd7kWP3Pp3=3F1qdg`0}wl{8;@$Kf>Ej*!%SIGFl&@-^k$quf>fV0ouoC zLG;Xp(<|GuL1daBnZn`T4@w%aT%kBSwfD}|oi94LE-cTjSk}SroVYZPmG05dzfMx@ zS_C?7!&YQ#0^BjDhV(0yGgF38=@QaErX=nI;SYEyz)=Cis(u9{G8NZJr>3_l&{GOT z1{86`5v(`^K8k^9c)*885?fJ~atiro9&!pcV=}*qrrTIYxFKJ-?#yzmn?`KIv0&K% zgYc|CkPw2*6bozJ^2C93w}7d!rs_?B?-Wu9TM*arHOq2cu$FkWXoLD(byQKCHgHQG z!%sngpf^W~n5*H52$C8A%PHS=nGQ{$LmkXrGkErx!a{Hd;NEe>@ie12k8~j~Y=Gz> z;u$hdh_NC%ymcg)QIB{dQ#X)4M{EJT@wbcw-S=wDp22XyCgFg9_?7hk4w4SwvQbl- z?5AEFo#ug((Ls7>V7wC43mrU3d0rO#<0DtENOS|pCyU9E@Y6-dB3eCh6H5H4*n9HS0jn(?k7T|YSJqO%<|>U z^vuAr&)eu&fkf^{|HqUyswl61@`aXqt)E8thw1t-;SY706z$sU!1+LDMrC3+EcleS z@(+`Lf?&XJLc~aLF;Qe^>n}mj)N5z&gjZPq>O=szou<1ee=fm1p8>i%0d_fQMPGzsMO7l(gLw!3J2Ty|=fP*e&dl;3_PkllKx8SIW$WtUMxP#bY#g?5AIL|#t6Whr{7=w= zPn#~SR{d|Us5iJ{k z!-xaV97Yoy0Ex~R*Z}fhp!DO>jzlLU$ku$jgPIbParBtzDB+k;HTE1|sW92d7T=SXi%X&3*Bv=Qmv9m@jB3M)CiOcI9xADa-tV8XHPx{b;q9* zrKf0eXa~Rbm+ZMkb`d&*aS@mQ4dQaJ(Yy`>A09%7LoDuIcRrPgi{}o0VHf$tI~w!T zb8p@Hvp@T@M0R$87yk_6Y7hNp9dm=eF!5h0K@DaF=8L9%VG1Zqlv*{Kx*j{Qw3m#n z90*cB_V95cP9Aw{BkzWqLF%@`Q=_vpCeBD=?7+lB&+K(~^Q1+ zm};^SYnU8no!rmvrNiVw+kqwEy;Mq9-^Iy0ka%Pj(a6#ZrQ4yJiHKdrl8Q-0 z#E*y=(sCm-k8I4^uuhzWS%JC=TZI<{?9OiJvTzoW8UrRmefTNh=U+@lFtpGM4>C7k z6xBVUw`(<;FD;7L-rdK>0m zqT#zpCm6v+b&joMI$!K$%hb~=XFGq`%~aSzF<-c;ocCF`5b1d;;T)-Wm~Stw2~uVf zFni#8PLR=b5U45{6@$zT4B7?i0Zvs$k`&-@wzus06PRF05cIC+yJ05oEetYcG!$FT z%rA-uK&bS8(b z7s0L`s+w!>yFoPf>m>c)ovL=n8*KOQ{M4*UXNaKepdeF2KF6hVy4W;k9>P|<3;D4b z%(=qU+UO?TCT1xljdF`Zp^1Y;ZD(R`F-8G?8MO-`i8u^L!O#)#BZ%AFt%Llf*qT=n ziHF=TTVH5EC959h@$;Mznt+5~|N7Pm)r2=AG@;@-EuV^cFc=~yryHtVnVzo5s-frY z2(&b@6<~^rH(^3+Qzd@{_8fvB%)$2?l+BU+Wq{|5)(J*c-7;RMqa9x|Ugr>le{Q_a zp-gWNsSuBq*=TX4@ z*mV|#F-Oi{y#EDfv9f`a@5D{%@*bRVJ}J0~qKg1{Xu&_e*=SD-4>b#7>Fje4$ZXto z=Y1P@-E;ALvE7_6E)_?GVx`rZ?atE2``(AeF z@8!GhEY8ojn)CDX*z^1cdhYGeBFIhAzagD-=|B6sgq;Lu!8}mA0;CP2&52AD0=6cg zbRz)@Y~m1?fRs%FD!e2nDUv1`k|jBy3|~AGwBXVy^pZ$pLbZ z93qFw5po?lN{(S{=W%j^oFq4pQ{+Z+6FE)JkekU_atk>}ZYAfX`|rHG(VCwhFI(ef zd%Wz7m)-HQH(vI~%fWcLFkUW>m)pn79pmNB@p9LAxqH0a7%f}l@>}EbTjTOu}EbTjTOu<8oW$a$DnaTjO$D<8oW$a$DnaTjO%u<8s^Ma@*r_+v9TE<8s^Ma@*r_ zK^{u#tvxQkJubgJF26l4zdbI$JubgJF26l4zcVhsGcLa~F26G_zcVhsGcLa~F26G_ zzcVhsGcLa~F26G_zcVhsGcLa~F26G_zdJ6!J1)OFF26f2zdJ6!J1)OFF26f2zdJ6! zJ1)OFF26f2zdJ6!J1)OFF26f2zc((wH!i<7E*}Yvq<(wj@_Xa*d*kwZ getPackages() { + return Arrays.asList( + new MainReactPackage(), + new VectorIconsPackage(), + new RNFirebasePackage() + ); + } + }; + + @Override + public ReactNativeHost getReactNativeHost() { + return mReactNativeHost; + } + + @Override + public void onCreate() { + super.onCreate(); + SoLoader.init(this, /* native exopackage */ false); + } +} diff --git a/tests/android/app/src/main/res/drawable-hdpi/ic_launcher.png b/tests/android/app/src/main/res/drawable-hdpi/ic_launcher.png new file mode 100755 index 0000000000000000000000000000000000000000..7164396bb30967ba6c18de6d7c96de542b3fee69 GIT binary patch literal 5271 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 z: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 WS3<-%|H&7S4Umyg6t5LE4*oBP9HF)V literal 0 HcmV?d00001 diff --git a/tests/android/app/src/main/res/drawable-xxxhdpi/ic_launcher.png b/tests/android/app/src/main/res/drawable-xxxhdpi/ic_launcher.png new file mode 100755 index 0000000000000000000000000000000000000000..e268634b4e9db4d446170e11c83ae2e24830d58c GIT binary patch literal 16380 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 M{gD=`643SkAHwIsrT_o{ literal 0 HcmV?d00001 diff --git a/tests/android/app/src/main/res/values/strings.xml b/tests/android/app/src/main/res/values/strings.xml new file mode 100644 index 00000000..b322c107 --- /dev/null +++ b/tests/android/app/src/main/res/values/strings.xml @@ -0,0 +1,3 @@ + + ReactNativeFirebaseDemo + diff --git a/tests/android/app/src/main/res/values/styles.xml b/tests/android/app/src/main/res/values/styles.xml new file mode 100644 index 00000000..319eb0ca --- /dev/null +++ b/tests/android/app/src/main/res/values/styles.xml @@ -0,0 +1,8 @@ + + + + + + diff --git a/tests/android/build.gradle b/tests/android/build.gradle new file mode 100644 index 00000000..41f6c1d8 --- /dev/null +++ b/tests/android/build.gradle @@ -0,0 +1,48 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. + +buildscript { + repositories { + jcenter() + } + dependencies { + classpath 'com.android.tools.build:gradle:2.3.0' + classpath 'com.google.gms:google-services:3.0.0' + + // NOTE: Do not place your application dependencies here; they belong + // in the individual module build.gradle files + } +} + +allprojects { + repositories { + mavenLocal() + jcenter() + maven { + // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm + url "$rootDir/../node_modules/react-native/android" + } + } +} + +subprojects { + ext { + compileSdk = 25 + buildTools = "25.0.2" + minSdk = 16 + targetSdk = 25 + } + + afterEvaluate { project -> + if (!project.name.equalsIgnoreCase("app") + && project.hasProperty("android")) { + android { + compileSdkVersion compileSdk + buildToolsVersion buildTools + defaultConfig { + minSdkVersion minSdk + targetSdkVersion targetSdk + } + } + } + } +} diff --git a/tests/android/gradle.properties b/tests/android/gradle.properties new file mode 100644 index 00000000..1fd964e9 --- /dev/null +++ b/tests/android/gradle.properties @@ -0,0 +1,20 @@ +# Project-wide Gradle settings. + +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. + +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html + +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +# Default value: -Xmx10248m -XX:MaxPermSize=256m +# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 + +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. More details, visit +# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects +# org.gradle.parallel=true + +android.useDeprecatedNdk=true diff --git a/tests/android/gradlew b/tests/android/gradlew new file mode 100755 index 00000000..9d82f789 --- /dev/null +++ b/tests/android/gradlew @@ -0,0 +1,160 @@ +#!/usr/bin/env bash + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS="" + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn ( ) { + echo "$*" +} + +die ( ) { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; +esac + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin, switch paths to Windows format before running java +if $cygwin ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules +function splitJvmOpts() { + JVM_OPTS=("$@") +} +eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS +JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" + +exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" diff --git a/tests/android/gradlew.bat b/tests/android/gradlew.bat new file mode 100644 index 00000000..aec99730 --- /dev/null +++ b/tests/android/gradlew.bat @@ -0,0 +1,90 @@ +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS= + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windowz variants + +if not "%OS%" == "Windows_NT" goto win9xME_args +if "%@eval[2+2]" == "4" goto 4NT_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* +goto execute + +:4NT_args +@rem Get arguments from the 4NT Shell from JP Software +set CMD_LINE_ARGS=%$ + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/tests/android/keystores/BUCK b/tests/android/keystores/BUCK new file mode 100644 index 00000000..15da20e6 --- /dev/null +++ b/tests/android/keystores/BUCK @@ -0,0 +1,8 @@ +keystore( + name = 'debug', + store = 'debug.keystore', + properties = 'debug.keystore.properties', + visibility = [ + 'PUBLIC', + ], +) diff --git a/tests/android/keystores/debug.keystore.properties b/tests/android/keystores/debug.keystore.properties new file mode 100644 index 00000000..121bfb49 --- /dev/null +++ b/tests/android/keystores/debug.keystore.properties @@ -0,0 +1,4 @@ +key.store=debug.keystore +key.alias=androiddebugkey +key.store.password=android +key.alias.password=android diff --git a/tests/android/settings.gradle b/tests/android/settings.gradle new file mode 100644 index 00000000..444f86ec --- /dev/null +++ b/tests/android/settings.gradle @@ -0,0 +1,7 @@ +rootProject.name = 'ReactNativeFirebaseDemo' +include ':react-native-firebase' +project(':react-native-firebase').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-firebase/android') +include ':react-native-vector-icons' +project(':react-native-vector-icons').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-vector-icons/android') + +include ':app' diff --git a/tests/docs/assets/test-suite-screenshot-android.png b/tests/docs/assets/test-suite-screenshot-android.png new file mode 100644 index 0000000000000000000000000000000000000000..a3a3f9dc0dccb4823215d08185a70a2e788b9a59 GIT binary patch literal 21824 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 A7XSbN literal 0 HcmV?d00001 diff --git a/tests/index.android.js b/tests/index.android.js new file mode 100644 index 00000000..9e8fc32c --- /dev/null +++ b/tests/index.android.js @@ -0,0 +1,5 @@ +import { AppRegistry } from 'react-native'; +import bootstrap from './src/main'; + + +AppRegistry.registerComponent('ReactNativeFirebaseDemo', () => bootstrap); diff --git a/tests/index.ios.js b/tests/index.ios.js new file mode 100644 index 00000000..597382bc --- /dev/null +++ b/tests/index.ios.js @@ -0,0 +1,4 @@ +import { AppRegistry } from 'react-native'; +import bootstrap from './src/main'; + +AppRegistry.registerComponent('ReactNativeFirebaseDemo', () => bootstrap); diff --git a/tests/ios/GoogleService-Info.plist b/tests/ios/GoogleService-Info.plist new file mode 100644 index 00000000..30da4b8d --- /dev/null +++ b/tests/ios/GoogleService-Info.plist @@ -0,0 +1,40 @@ + + + + + AD_UNIT_ID_FOR_BANNER_TEST + ca-app-pub-3940256099942544/2934735716 + AD_UNIT_ID_FOR_INTERSTITIAL_TEST + ca-app-pub-3940256099942544/4411468910 + CLIENT_ID + 305229645282-22imndi01abc2p6esgtu1i1m9mqrd0ib.apps.googleusercontent.com + REVERSED_CLIENT_ID + com.googleusercontent.apps.305229645282-22imndi01abc2p6esgtu1i1m9mqrd0ib + API_KEY + AIzaSyAcdVLG5dRzA1ck_fa_xd4Z0cY7cga7S5A + GCM_SENDER_ID + 305229645282 + PLIST_VERSION + 1 + BUNDLE_ID + com.invertase.ReactNativeFirebaseDemo + PROJECT_ID + rnfirebase-b9ad4 + STORAGE_BUCKET + rnfirebase-b9ad4.appspot.com + IS_ADS_ENABLED + + IS_ANALYTICS_ENABLED + + IS_APPINVITE_ENABLED + + IS_GCM_ENABLED + + IS_SIGNIN_ENABLED + + GOOGLE_APP_ID + 1:305229645282:ios:7b45748cb1117d2d + DATABASE_URL + https://rnfirebase-b9ad4.firebaseio.com + + \ No newline at end of file diff --git a/tests/ios/ReactNativeFirebaseDemo-tvOS/Info.plist b/tests/ios/ReactNativeFirebaseDemo-tvOS/Info.plist new file mode 100644 index 00000000..2fb6a11c --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo-tvOS/Info.plist @@ -0,0 +1,54 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1 + LSRequiresIPhoneOS + + UILaunchStoryboardName + LaunchScreen + UIRequiredDeviceCapabilities + + armv7 + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UIViewControllerBasedStatusBarAppearance + + NSLocationWhenInUseUsageDescription + + NSAppTransportSecurity + + + NSExceptionDomains + + localhost + + NSExceptionAllowsInsecureHTTPLoads + + + + + + diff --git a/tests/ios/ReactNativeFirebaseDemo-tvOSTests/Info.plist b/tests/ios/ReactNativeFirebaseDemo-tvOSTests/Info.plist new file mode 100644 index 00000000..886825cc --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo-tvOSTests/Info.plist @@ -0,0 +1,24 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + BNDL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1 + + diff --git a/tests/ios/ReactNativeFirebaseDemo.xcodeproj/project.pbxproj b/tests/ios/ReactNativeFirebaseDemo.xcodeproj/project.pbxproj new file mode 100644 index 00000000..de8d448e --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo.xcodeproj/project.pbxproj @@ -0,0 +1,1537 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + 00C302E51ABCBA2D00DB3ED1 /* libRCTActionSheet.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */; }; + 00C302E71ABCBA2D00DB3ED1 /* libRCTGeolocation.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */; }; + 00C302E81ABCBA2D00DB3ED1 /* libRCTImage.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302C01ABCB91800DB3ED1 /* libRCTImage.a */; }; + 00C302E91ABCBA2D00DB3ED1 /* libRCTNetwork.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */; }; + 00C302EA1ABCBA2D00DB3ED1 /* libRCTVibration.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */; }; + 00E356F31AD99517003FC87E /* ReactNativeFirebaseDemoTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 00E356F21AD99517003FC87E /* ReactNativeFirebaseDemoTests.m */; }; + 076B30A1D09C6AEEAE912DEB /* libPods-ReactNativeFirebaseDemo.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 42C7056622ACE9D1E626AD4C /* libPods-ReactNativeFirebaseDemo.a */; }; + 133E29F31AD74F7200F7D852 /* libRCTLinking.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 78C398B91ACF4ADC00677621 /* libRCTLinking.a */; }; + 139105C61AF99C1200B5F7CC /* libRCTSettings.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 139105C11AF99BAD00B5F7CC /* libRCTSettings.a */; }; + 139FDEF61B0652A700C62182 /* libRCTWebSocket.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 139FDEF41B06529B00C62182 /* libRCTWebSocket.a */; }; + 13B07FBC1A68108700A75B9A /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB01A68108700A75B9A /* AppDelegate.m */; }; + 13B07FBD1A68108700A75B9A /* LaunchScreen.xib in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB11A68108700A75B9A /* LaunchScreen.xib */; }; + 13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB51A68108700A75B9A /* Images.xcassets */; }; + 13B07FC11A68108700A75B9A /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB71A68108700A75B9A /* main.m */; }; + 140ED2AC1D01E1AD002B40FF /* libReact.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 146834041AC3E56700842450 /* libReact.a */; }; + 146834051AC3E58100842450 /* libReact.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 146834041AC3E56700842450 /* libReact.a */; }; + 1852BC611C674A2E905975BC /* Foundation.ttf in Resources */ = {isa = PBXBuildFile; fileRef = 5F6AF99C2A6F4545B0F74832 /* Foundation.ttf */; }; + 211A77BD015F4D728A9B6E72 /* FontAwesome.ttf in Resources */ = {isa = PBXBuildFile; fileRef = 7DD9301D866B4D52A7F83996 /* FontAwesome.ttf */; }; + 2D02E4BC1E0B4A80006451C7 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB01A68108700A75B9A /* AppDelegate.m */; }; + 2D02E4BD1E0B4A84006451C7 /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB51A68108700A75B9A /* Images.xcassets */; }; + 2D02E4BF1E0B4AB3006451C7 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 13B07FB71A68108700A75B9A /* main.m */; }; + 2D02E4C21E0B4AEC006451C7 /* libRCTAnimation-tvOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5E9157351DD0AC6500FF2AA8 /* libRCTAnimation-tvOS.a */; }; + 2D02E4C31E0B4AEC006451C7 /* libRCTImage-tvOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 3DAD3E841DF850E9000B6D8A /* libRCTImage-tvOS.a */; }; + 2D02E4C41E0B4AEC006451C7 /* libRCTLinking-tvOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 3DAD3E881DF850E9000B6D8A /* libRCTLinking-tvOS.a */; }; + 2D02E4C51E0B4AEC006451C7 /* libRCTNetwork-tvOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 3DAD3E8C1DF850E9000B6D8A /* libRCTNetwork-tvOS.a */; }; + 2D02E4C61E0B4AEC006451C7 /* libRCTSettings-tvOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 3DAD3E901DF850E9000B6D8A /* libRCTSettings-tvOS.a */; }; + 2D02E4C71E0B4AEC006451C7 /* libRCTText-tvOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 3DAD3E941DF850E9000B6D8A /* libRCTText-tvOS.a */; }; + 2D02E4C81E0B4AEC006451C7 /* libRCTWebSocket-tvOS.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 3DAD3E991DF850E9000B6D8A /* libRCTWebSocket-tvOS.a */; }; + 2D02E4C91E0B4AEC006451C7 /* libReact.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 3DAD3EA31DF850E9000B6D8A /* libReact.a */; }; + 2DCD954D1E0B4F2C00145EB5 /* ReactNativeFirebaseDemoTests.m in Sources */ = {isa = PBXBuildFile; fileRef = 00E356F21AD99517003FC87E /* ReactNativeFirebaseDemoTests.m */; }; + 42A0E8F428A74B23B4C7D95A /* SimpleLineIcons.ttf in Resources */ = {isa = PBXBuildFile; fileRef = FD3DFC8253C74B6298AFD3B7 /* SimpleLineIcons.ttf */; }; + 5E9157361DD0AC6A00FF2AA8 /* libRCTAnimation.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5E9157331DD0AC6500FF2AA8 /* libRCTAnimation.a */; }; + 644044EA167D431D96D0E6C1 /* libLRDRCTSimpleToast.a in Frameworks */ = {isa = PBXBuildFile; fileRef = BBEE706291534F5F948A3805 /* libLRDRCTSimpleToast.a */; }; + 6F307BC16AD047C8BD921730 /* MaterialCommunityIcons.ttf in Resources */ = {isa = PBXBuildFile; fileRef = 7A6F0C1C198B4A6FB4AB907D /* MaterialCommunityIcons.ttf */; }; + 82FE196A2ADC4D29BB2CB4BF /* Ionicons.ttf in Resources */ = {isa = PBXBuildFile; fileRef = 48961CCCEE8947FB9EE3658F /* Ionicons.ttf */; }; + 832341BD1AAA6AB300B99B32 /* libRCTText.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 832341B51AAA6A8300B99B32 /* libRCTText.a */; }; + 885057F5D1FA461AAAE0B487 /* Octicons.ttf in Resources */ = {isa = PBXBuildFile; fileRef = CC24EB30F0484352BD65FFC1 /* Octicons.ttf */; }; + 8EE7622C1E718A8600B1E0F6 /* GoogleService-Info.plist in Resources */ = {isa = PBXBuildFile; fileRef = 8EE7622B1E718A8600B1E0F6 /* GoogleService-Info.plist */; }; + 9D2381E3C2D340BA9A0737E2 /* MaterialIcons.ttf in Resources */ = {isa = PBXBuildFile; fileRef = 739DB016E64944BE99C338C4 /* MaterialIcons.ttf */; }; + D46EBD0604CE40EFB18F8A35 /* Zocial.ttf in Resources */ = {isa = PBXBuildFile; fileRef = 182271FFECD74C3B92960E1D /* Zocial.ttf */; }; + E51DA6317685417F97A59475 /* libRNVectorIcons.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0C76E33ACF004369AEB318B1 /* libRNVectorIcons.a */; }; + EA30CACE4CB84AC1BAE59432 /* Entypo.ttf in Resources */ = {isa = PBXBuildFile; fileRef = 4935BEDE99B9436581953E77 /* Entypo.ttf */; }; + F57EC9E3C5414A99821B73F4 /* EvilIcons.ttf in Resources */ = {isa = PBXBuildFile; fileRef = DB5BB32AF70B41678974C6B4 /* EvilIcons.ttf */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 00C302AB1ABCB8CE00DB3ED1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 134814201AA4EA6300B7C361; + remoteInfo = RCTActionSheet; + }; + 00C302B91ABCB90400DB3ED1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 134814201AA4EA6300B7C361; + remoteInfo = RCTGeolocation; + }; + 00C302BF1ABCB91800DB3ED1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 58B5115D1A9E6B3D00147676; + remoteInfo = RCTImage; + }; + 00C302DB1ABCB9D200DB3ED1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 58B511DB1A9E6C8500147676; + remoteInfo = RCTNetwork; + }; + 00C302E31ABCB9EE00DB3ED1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 832C81801AAF6DEF007FA2F7; + remoteInfo = RCTVibration; + }; + 00E356F41AD99517003FC87E /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 83CBB9F71A601CBA00E9B192 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 13B07F861A680F5B00A75B9A; + remoteInfo = ReactNativeFirebaseDemo; + }; + 139105C01AF99BAD00B5F7CC /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 134814201AA4EA6300B7C361; + remoteInfo = RCTSettings; + }; + 139FDEF31B06529B00C62182 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 3C86DF461ADF2C930047B81A; + remoteInfo = RCTWebSocket; + }; + 146834031AC3E56700842450 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 83CBBA2E1A601D0E00E9B192; + remoteInfo = React; + }; + 2D02E4911E0B4A5D006451C7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 83CBB9F71A601CBA00E9B192 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 2D02E47A1E0B4A5D006451C7; + remoteInfo = "ReactNativeFirebaseDemo-tvOS"; + }; + 3DAD3E831DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 2D2A283A1D9B042B00D4039D; + remoteInfo = "RCTImage-tvOS"; + }; + 3DAD3E871DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 2D2A28471D9B043800D4039D; + remoteInfo = "RCTLinking-tvOS"; + }; + 3DAD3E8B1DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 2D2A28541D9B044C00D4039D; + remoteInfo = "RCTNetwork-tvOS"; + }; + 3DAD3E8F1DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 2D2A28611D9B046600D4039D; + remoteInfo = "RCTSettings-tvOS"; + }; + 3DAD3E931DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 2D2A287B1D9B048500D4039D; + remoteInfo = "RCTText-tvOS"; + }; + 3DAD3E981DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 2D2A28881D9B049200D4039D; + remoteInfo = "RCTWebSocket-tvOS"; + }; + 3DAD3EA21DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 2D2A28131D9B038B00D4039D; + remoteInfo = "React-tvOS"; + }; + 3DAD3EA41DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 3D3C059A1DE3340900C268FA; + remoteInfo = yoga; + }; + 3DAD3EA61DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 3D3C06751DE3340C00C268FA; + remoteInfo = "yoga-tvOS"; + }; + 3DAD3EA81DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 3D3CD9251DE5FBEC00167DC4; + remoteInfo = cxxreact; + }; + 3DAD3EAA1DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 3D3CD9321DE5FBEE00167DC4; + remoteInfo = "cxxreact-tvOS"; + }; + 3DAD3EAC1DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 3D3CD90B1DE5FBD600167DC4; + remoteInfo = jschelpers; + }; + 3DAD3EAE1DF850E9000B6D8A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 146833FF1AC3E56700842450 /* React.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 3D3CD9181DE5FBD800167DC4; + remoteInfo = "jschelpers-tvOS"; + }; + 5E9157321DD0AC6500FF2AA8 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 5E91572D1DD0AC6500FF2AA8 /* RCTAnimation.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 134814201AA4EA6300B7C361; + remoteInfo = RCTAnimation; + }; + 5E9157341DD0AC6500FF2AA8 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 5E91572D1DD0AC6500FF2AA8 /* RCTAnimation.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 2D2A28201D9B03D100D4039D; + remoteInfo = "RCTAnimation-tvOS"; + }; + 78C398B81ACF4ADC00677621 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 134814201AA4EA6300B7C361; + remoteInfo = RCTLinking; + }; + 832341B41AAA6A8300B99B32 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 58B5119B1A9E6C1200147676; + remoteInfo = RCTText; + }; + 997890041E69DE2900F6820C /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = C7C48FEEC8E34DE4BB5DE211 /* RNFirebase.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = E26E29F41BBE54B800BF9CD9; + remoteInfo = RNFirebase; + }; + 997890071E69DE2900F6820C /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 8BE028F5B04B4DC3BEF0305F /* RNVectorIcons.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 5DBEB1501B18CEA900B34395; + remoteInfo = RNVectorIcons; + }; + 997890191E6D86E700F6820C /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 78C4D9D5FCAA43A384C23C35 /* LRDRCTSimpleToast.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 15209BEF1D250F63000D0F44; + remoteInfo = LRDRCTSimpleToast; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + 008F07F21AC5B25A0029DE68 /* main.jsbundle */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = main.jsbundle; sourceTree = ""; }; + 00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTActionSheet.xcodeproj; path = "../node_modules/react-native/Libraries/ActionSheetIOS/RCTActionSheet.xcodeproj"; sourceTree = ""; }; + 00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTGeolocation.xcodeproj; path = "../node_modules/react-native/Libraries/Geolocation/RCTGeolocation.xcodeproj"; sourceTree = ""; }; + 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTImage.xcodeproj; path = "../node_modules/react-native/Libraries/Image/RCTImage.xcodeproj"; sourceTree = ""; }; + 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTNetwork.xcodeproj; path = "../node_modules/react-native/Libraries/Network/RCTNetwork.xcodeproj"; sourceTree = ""; }; + 00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTVibration.xcodeproj; path = "../node_modules/react-native/Libraries/Vibration/RCTVibration.xcodeproj"; sourceTree = ""; }; + 00E356EE1AD99517003FC87E /* ReactNativeFirebaseDemoTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = ReactNativeFirebaseDemoTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 00E356F11AD99517003FC87E /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 00E356F21AD99517003FC87E /* ReactNativeFirebaseDemoTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ReactNativeFirebaseDemoTests.m; sourceTree = ""; }; + 07C05CEFA32C3C442CA152DB /* Pods-ReactNativeFirebaseDemo.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-ReactNativeFirebaseDemo.debug.xcconfig"; path = "Pods/Target Support Files/Pods-ReactNativeFirebaseDemo/Pods-ReactNativeFirebaseDemo.debug.xcconfig"; sourceTree = ""; }; + 0C76E33ACF004369AEB318B1 /* libRNVectorIcons.a */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = archive.ar; path = libRNVectorIcons.a; sourceTree = ""; }; + 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTSettings.xcodeproj; path = "../node_modules/react-native/Libraries/Settings/RCTSettings.xcodeproj"; sourceTree = ""; }; + 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTWebSocket.xcodeproj; path = "../node_modules/react-native/Libraries/WebSocket/RCTWebSocket.xcodeproj"; sourceTree = ""; }; + 13B07F961A680F5B00A75B9A /* ReactNativeFirebaseDemo.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = ReactNativeFirebaseDemo.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 13B07FAF1A68108700A75B9A /* AppDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AppDelegate.h; path = ReactNativeFirebaseDemo/AppDelegate.h; sourceTree = ""; }; + 13B07FB01A68108700A75B9A /* AppDelegate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = AppDelegate.m; path = ReactNativeFirebaseDemo/AppDelegate.m; sourceTree = ""; }; + 13B07FB21A68108700A75B9A /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/LaunchScreen.xib; sourceTree = ""; }; + 13B07FB51A68108700A75B9A /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Images.xcassets; path = ReactNativeFirebaseDemo/Images.xcassets; sourceTree = ""; }; + 13B07FB61A68108700A75B9A /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = ReactNativeFirebaseDemo/Info.plist; sourceTree = ""; }; + 13B07FB71A68108700A75B9A /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = main.m; path = ReactNativeFirebaseDemo/main.m; sourceTree = ""; }; + 146833FF1AC3E56700842450 /* React.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = React.xcodeproj; path = "../node_modules/react-native/React/React.xcodeproj"; sourceTree = ""; }; + 182271FFECD74C3B92960E1D /* Zocial.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = Zocial.ttf; path = "../node_modules/react-native-vector-icons/Fonts/Zocial.ttf"; sourceTree = ""; }; + 2D02E47B1E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOS.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = "ReactNativeFirebaseDemo-tvOS.app"; sourceTree = BUILT_PRODUCTS_DIR; }; + 2D02E4901E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOSTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "ReactNativeFirebaseDemo-tvOSTests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; }; + 42C7056622ACE9D1E626AD4C /* libPods-ReactNativeFirebaseDemo.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-ReactNativeFirebaseDemo.a"; sourceTree = BUILT_PRODUCTS_DIR; }; + 48961CCCEE8947FB9EE3658F /* Ionicons.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = Ionicons.ttf; path = "../node_modules/react-native-vector-icons/Fonts/Ionicons.ttf"; sourceTree = ""; }; + 4935BEDE99B9436581953E77 /* Entypo.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = Entypo.ttf; path = "../node_modules/react-native-vector-icons/Fonts/Entypo.ttf"; sourceTree = ""; }; + 5E91572D1DD0AC6500FF2AA8 /* RCTAnimation.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTAnimation.xcodeproj; path = "../node_modules/react-native/Libraries/NativeAnimation/RCTAnimation.xcodeproj"; sourceTree = ""; }; + 5F6AF99C2A6F4545B0F74832 /* Foundation.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = Foundation.ttf; path = "../node_modules/react-native-vector-icons/Fonts/Foundation.ttf"; sourceTree = ""; }; + 739DB016E64944BE99C338C4 /* MaterialIcons.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = MaterialIcons.ttf; path = "../node_modules/react-native-vector-icons/Fonts/MaterialIcons.ttf"; sourceTree = ""; }; + 7791402B6343C1906BE4D13A /* libPods-ReactNativeFirebaseDemoTests.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-ReactNativeFirebaseDemoTests.a"; sourceTree = BUILT_PRODUCTS_DIR; }; + 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTLinking.xcodeproj; path = "../node_modules/react-native/Libraries/LinkingIOS/RCTLinking.xcodeproj"; sourceTree = ""; }; + 78C4D9D5FCAA43A384C23C35 /* LRDRCTSimpleToast.xcodeproj */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = "wrapper.pb-project"; name = LRDRCTSimpleToast.xcodeproj; path = "../node_modules/react-native-simple-toast/ios/LRDRCTSimpleToast.xcodeproj"; sourceTree = ""; }; + 7A6F0C1C198B4A6FB4AB907D /* MaterialCommunityIcons.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = MaterialCommunityIcons.ttf; path = "../node_modules/react-native-vector-icons/Fonts/MaterialCommunityIcons.ttf"; sourceTree = ""; }; + 7DD9301D866B4D52A7F83996 /* FontAwesome.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = FontAwesome.ttf; path = "../node_modules/react-native-vector-icons/Fonts/FontAwesome.ttf"; sourceTree = ""; }; + 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = RCTText.xcodeproj; path = "../node_modules/react-native/Libraries/Text/RCTText.xcodeproj"; sourceTree = ""; }; + 8BE028F5B04B4DC3BEF0305F /* RNVectorIcons.xcodeproj */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = "wrapper.pb-project"; name = RNVectorIcons.xcodeproj; path = "../node_modules/react-native-vector-icons/RNVectorIcons.xcodeproj"; sourceTree = ""; }; + 8EE7622B1E718A8600B1E0F6 /* GoogleService-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = "GoogleService-Info.plist"; sourceTree = ""; }; + 93FF19757985B70080544398 /* Pods-ReactNativeFirebaseDemo.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-ReactNativeFirebaseDemo.release.xcconfig"; path = "Pods/Target Support Files/Pods-ReactNativeFirebaseDemo/Pods-ReactNativeFirebaseDemo.release.xcconfig"; sourceTree = ""; }; + BBEE706291534F5F948A3805 /* libLRDRCTSimpleToast.a */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = archive.ar; path = libLRDRCTSimpleToast.a; sourceTree = ""; }; + C7C48FEEC8E34DE4BB5DE211 /* RNFirebase.xcodeproj */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = "wrapper.pb-project"; name = RNFirebase.xcodeproj; path = "../node_modules/react-native-firebase/RNFirebase.xcodeproj"; sourceTree = ""; }; + CC24EB30F0484352BD65FFC1 /* Octicons.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = Octicons.ttf; path = "../node_modules/react-native-vector-icons/Fonts/Octicons.ttf"; sourceTree = ""; }; + DB5BB32AF70B41678974C6B4 /* EvilIcons.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = EvilIcons.ttf; path = "../node_modules/react-native-vector-icons/Fonts/EvilIcons.ttf"; sourceTree = ""; }; + FD3DFC8253C74B6298AFD3B7 /* SimpleLineIcons.ttf */ = {isa = PBXFileReference; explicitFileType = undefined; fileEncoding = 9; includeInIndex = 0; lastKnownFileType = unknown; name = SimpleLineIcons.ttf; path = "../node_modules/react-native-vector-icons/Fonts/SimpleLineIcons.ttf"; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 00E356EB1AD99517003FC87E /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 140ED2AC1D01E1AD002B40FF /* libReact.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 13B07F8C1A680F5B00A75B9A /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 146834051AC3E58100842450 /* libReact.a in Frameworks */, + 5E9157361DD0AC6A00FF2AA8 /* libRCTAnimation.a in Frameworks */, + 00C302E51ABCBA2D00DB3ED1 /* libRCTActionSheet.a in Frameworks */, + 00C302E71ABCBA2D00DB3ED1 /* libRCTGeolocation.a in Frameworks */, + 00C302E81ABCBA2D00DB3ED1 /* libRCTImage.a in Frameworks */, + 133E29F31AD74F7200F7D852 /* libRCTLinking.a in Frameworks */, + 00C302E91ABCBA2D00DB3ED1 /* libRCTNetwork.a in Frameworks */, + 139105C61AF99C1200B5F7CC /* libRCTSettings.a in Frameworks */, + 832341BD1AAA6AB300B99B32 /* libRCTText.a in Frameworks */, + 00C302EA1ABCBA2D00DB3ED1 /* libRCTVibration.a in Frameworks */, + 139FDEF61B0652A700C62182 /* libRCTWebSocket.a in Frameworks */, + E51DA6317685417F97A59475 /* libRNVectorIcons.a in Frameworks */, + 644044EA167D431D96D0E6C1 /* libLRDRCTSimpleToast.a in Frameworks */, + 076B30A1D09C6AEEAE912DEB /* libPods-ReactNativeFirebaseDemo.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 2D02E4781E0B4A5D006451C7 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 2D02E4C91E0B4AEC006451C7 /* libReact.a in Frameworks */, + 2D02E4C21E0B4AEC006451C7 /* libRCTAnimation-tvOS.a in Frameworks */, + 2D02E4C31E0B4AEC006451C7 /* libRCTImage-tvOS.a in Frameworks */, + 2D02E4C41E0B4AEC006451C7 /* libRCTLinking-tvOS.a in Frameworks */, + 2D02E4C51E0B4AEC006451C7 /* libRCTNetwork-tvOS.a in Frameworks */, + 2D02E4C61E0B4AEC006451C7 /* libRCTSettings-tvOS.a in Frameworks */, + 2D02E4C71E0B4AEC006451C7 /* libRCTText-tvOS.a in Frameworks */, + 2D02E4C81E0B4AEC006451C7 /* libRCTWebSocket-tvOS.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 2D02E48D1E0B4A5D006451C7 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 00C302A81ABCB8CE00DB3ED1 /* Products */ = { + isa = PBXGroup; + children = ( + 00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */, + ); + name = Products; + sourceTree = ""; + }; + 00C302B61ABCB90400DB3ED1 /* Products */ = { + isa = PBXGroup; + children = ( + 00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */, + ); + name = Products; + sourceTree = ""; + }; + 00C302BC1ABCB91800DB3ED1 /* Products */ = { + isa = PBXGroup; + children = ( + 00C302C01ABCB91800DB3ED1 /* libRCTImage.a */, + 3DAD3E841DF850E9000B6D8A /* libRCTImage-tvOS.a */, + ); + name = Products; + sourceTree = ""; + }; + 00C302D41ABCB9D200DB3ED1 /* Products */ = { + isa = PBXGroup; + children = ( + 00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */, + 3DAD3E8C1DF850E9000B6D8A /* libRCTNetwork-tvOS.a */, + ); + name = Products; + sourceTree = ""; + }; + 00C302E01ABCB9EE00DB3ED1 /* Products */ = { + isa = PBXGroup; + children = ( + 00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */, + ); + name = Products; + sourceTree = ""; + }; + 00E356EF1AD99517003FC87E /* ReactNativeFirebaseDemoTests */ = { + isa = PBXGroup; + children = ( + 00E356F21AD99517003FC87E /* ReactNativeFirebaseDemoTests.m */, + 00E356F01AD99517003FC87E /* Supporting Files */, + ); + path = ReactNativeFirebaseDemoTests; + sourceTree = ""; + }; + 00E356F01AD99517003FC87E /* Supporting Files */ = { + isa = PBXGroup; + children = ( + 00E356F11AD99517003FC87E /* Info.plist */, + ); + name = "Supporting Files"; + sourceTree = ""; + }; + 0D55D6BB72314357439E4EE9 /* Pods */ = { + isa = PBXGroup; + children = ( + 07C05CEFA32C3C442CA152DB /* Pods-ReactNativeFirebaseDemo.debug.xcconfig */, + 93FF19757985B70080544398 /* Pods-ReactNativeFirebaseDemo.release.xcconfig */, + ); + name = Pods; + sourceTree = ""; + }; + 139105B71AF99BAD00B5F7CC /* Products */ = { + isa = PBXGroup; + children = ( + 139105C11AF99BAD00B5F7CC /* libRCTSettings.a */, + 3DAD3E901DF850E9000B6D8A /* libRCTSettings-tvOS.a */, + ); + name = Products; + sourceTree = ""; + }; + 139FDEE71B06529A00C62182 /* Products */ = { + isa = PBXGroup; + children = ( + 139FDEF41B06529B00C62182 /* libRCTWebSocket.a */, + 3DAD3E991DF850E9000B6D8A /* libRCTWebSocket-tvOS.a */, + ); + name = Products; + sourceTree = ""; + }; + 13B07FAE1A68108700A75B9A /* ReactNativeFirebaseDemo */ = { + isa = PBXGroup; + children = ( + 8EE7622B1E718A8600B1E0F6 /* GoogleService-Info.plist */, + 008F07F21AC5B25A0029DE68 /* main.jsbundle */, + 13B07FAF1A68108700A75B9A /* AppDelegate.h */, + 13B07FB01A68108700A75B9A /* AppDelegate.m */, + 13B07FB51A68108700A75B9A /* Images.xcassets */, + 13B07FB61A68108700A75B9A /* Info.plist */, + 13B07FB11A68108700A75B9A /* LaunchScreen.xib */, + 13B07FB71A68108700A75B9A /* main.m */, + ); + name = ReactNativeFirebaseDemo; + sourceTree = ""; + }; + 146834001AC3E56700842450 /* Products */ = { + isa = PBXGroup; + children = ( + 146834041AC3E56700842450 /* libReact.a */, + 3DAD3EA31DF850E9000B6D8A /* libReact.a */, + 3DAD3EA51DF850E9000B6D8A /* libyoga.a */, + 3DAD3EA71DF850E9000B6D8A /* libyoga.a */, + 3DAD3EA91DF850E9000B6D8A /* libcxxreact.a */, + 3DAD3EAB1DF850E9000B6D8A /* libcxxreact.a */, + 3DAD3EAD1DF850E9000B6D8A /* libjschelpers.a */, + 3DAD3EAF1DF850E9000B6D8A /* libjschelpers.a */, + ); + name = Products; + sourceTree = ""; + }; + 3F2926F67DDFAB9753757355 /* Frameworks */ = { + isa = PBXGroup; + children = ( + 42C7056622ACE9D1E626AD4C /* libPods-ReactNativeFirebaseDemo.a */, + 7791402B6343C1906BE4D13A /* libPods-ReactNativeFirebaseDemoTests.a */, + ); + name = Frameworks; + sourceTree = ""; + }; + 5E91572E1DD0AC6500FF2AA8 /* Products */ = { + isa = PBXGroup; + children = ( + 5E9157331DD0AC6500FF2AA8 /* libRCTAnimation.a */, + 5E9157351DD0AC6500FF2AA8 /* libRCTAnimation-tvOS.a */, + ); + name = Products; + sourceTree = ""; + }; + 78C398B11ACF4ADC00677621 /* Products */ = { + isa = PBXGroup; + children = ( + 78C398B91ACF4ADC00677621 /* libRCTLinking.a */, + 3DAD3E881DF850E9000B6D8A /* libRCTLinking-tvOS.a */, + ); + name = Products; + sourceTree = ""; + }; + 832341AE1AAA6A7D00B99B32 /* Libraries */ = { + isa = PBXGroup; + children = ( + 5E91572D1DD0AC6500FF2AA8 /* RCTAnimation.xcodeproj */, + 146833FF1AC3E56700842450 /* React.xcodeproj */, + 00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */, + 00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */, + 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */, + 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */, + 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */, + 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */, + 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */, + 00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */, + 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */, + C7C48FEEC8E34DE4BB5DE211 /* RNFirebase.xcodeproj */, + 8BE028F5B04B4DC3BEF0305F /* RNVectorIcons.xcodeproj */, + 78C4D9D5FCAA43A384C23C35 /* LRDRCTSimpleToast.xcodeproj */, + ); + name = Libraries; + sourceTree = ""; + }; + 832341B11AAA6A8300B99B32 /* Products */ = { + isa = PBXGroup; + children = ( + 832341B51AAA6A8300B99B32 /* libRCTText.a */, + 3DAD3E941DF850E9000B6D8A /* libRCTText-tvOS.a */, + ); + name = Products; + sourceTree = ""; + }; + 83CBB9F61A601CBA00E9B192 = { + isa = PBXGroup; + children = ( + 13B07FAE1A68108700A75B9A /* ReactNativeFirebaseDemo */, + 832341AE1AAA6A7D00B99B32 /* Libraries */, + 00E356EF1AD99517003FC87E /* ReactNativeFirebaseDemoTests */, + 83CBBA001A601CBA00E9B192 /* Products */, + F50F62EA16044AFF8BD7CF63 /* Resources */, + 0D55D6BB72314357439E4EE9 /* Pods */, + 3F2926F67DDFAB9753757355 /* Frameworks */, + ); + indentWidth = 2; + sourceTree = ""; + tabWidth = 2; + }; + 83CBBA001A601CBA00E9B192 /* Products */ = { + isa = PBXGroup; + children = ( + 13B07F961A680F5B00A75B9A /* ReactNativeFirebaseDemo.app */, + 00E356EE1AD99517003FC87E /* ReactNativeFirebaseDemoTests.xctest */, + 2D02E47B1E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOS.app */, + 2D02E4901E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOSTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 99788FE61E69DE2900F6820C /* Products */ = { + isa = PBXGroup; + children = ( + 997890051E69DE2900F6820C /* RNFirebase.framework */, + ); + name = Products; + sourceTree = ""; + }; + 99788FE81E69DE2900F6820C /* Products */ = { + isa = PBXGroup; + children = ( + 997890081E69DE2900F6820C /* libRNVectorIcons.a */, + ); + name = Products; + sourceTree = ""; + }; + 997890161E6D86E700F6820C /* Products */ = { + isa = PBXGroup; + children = ( + 9978901A1E6D86E700F6820C /* libLRDRCTSimpleToast.a */, + ); + name = Products; + sourceTree = ""; + }; + F50F62EA16044AFF8BD7CF63 /* Resources */ = { + isa = PBXGroup; + children = ( + 4935BEDE99B9436581953E77 /* Entypo.ttf */, + DB5BB32AF70B41678974C6B4 /* EvilIcons.ttf */, + 7DD9301D866B4D52A7F83996 /* FontAwesome.ttf */, + 5F6AF99C2A6F4545B0F74832 /* Foundation.ttf */, + 48961CCCEE8947FB9EE3658F /* Ionicons.ttf */, + 7A6F0C1C198B4A6FB4AB907D /* MaterialCommunityIcons.ttf */, + 739DB016E64944BE99C338C4 /* MaterialIcons.ttf */, + CC24EB30F0484352BD65FFC1 /* Octicons.ttf */, + FD3DFC8253C74B6298AFD3B7 /* SimpleLineIcons.ttf */, + 182271FFECD74C3B92960E1D /* Zocial.ttf */, + ); + name = Resources; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 00E356ED1AD99517003FC87E /* ReactNativeFirebaseDemoTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 00E357021AD99517003FC87E /* Build configuration list for PBXNativeTarget "ReactNativeFirebaseDemoTests" */; + buildPhases = ( + 00E356EA1AD99517003FC87E /* Sources */, + 00E356EB1AD99517003FC87E /* Frameworks */, + 00E356EC1AD99517003FC87E /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 00E356F51AD99517003FC87E /* PBXTargetDependency */, + ); + name = ReactNativeFirebaseDemoTests; + productName = ReactNativeFirebaseDemoTests; + productReference = 00E356EE1AD99517003FC87E /* ReactNativeFirebaseDemoTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 13B07F861A680F5B00A75B9A /* ReactNativeFirebaseDemo */ = { + isa = PBXNativeTarget; + buildConfigurationList = 13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "ReactNativeFirebaseDemo" */; + buildPhases = ( + 26F9B43687A3EAE646F8970D /* [CP] Check Pods Manifest.lock */, + 13B07F871A680F5B00A75B9A /* Sources */, + 13B07F8C1A680F5B00A75B9A /* Frameworks */, + 13B07F8E1A680F5B00A75B9A /* Resources */, + 00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */, + C015646CE8F8CB4B578CE178 /* [CP] Embed Pods Frameworks */, + 6AE1012F46FF8A4D1D818A12 /* [CP] Copy Pods Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = ReactNativeFirebaseDemo; + productName = "Hello World"; + productReference = 13B07F961A680F5B00A75B9A /* ReactNativeFirebaseDemo.app */; + productType = "com.apple.product-type.application"; + }; + 2D02E47A1E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOS */ = { + isa = PBXNativeTarget; + buildConfigurationList = 2D02E4BA1E0B4A5E006451C7 /* Build configuration list for PBXNativeTarget "ReactNativeFirebaseDemo-tvOS" */; + buildPhases = ( + 2D02E4771E0B4A5D006451C7 /* Sources */, + 2D02E4781E0B4A5D006451C7 /* Frameworks */, + 2D02E4791E0B4A5D006451C7 /* Resources */, + 2D02E4CB1E0B4B27006451C7 /* Bundle React Native Code And Images */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = "ReactNativeFirebaseDemo-tvOS"; + productName = "ReactNativeFirebaseDemo-tvOS"; + productReference = 2D02E47B1E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOS.app */; + productType = "com.apple.product-type.application"; + }; + 2D02E48F1E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOSTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 2D02E4BB1E0B4A5E006451C7 /* Build configuration list for PBXNativeTarget "ReactNativeFirebaseDemo-tvOSTests" */; + buildPhases = ( + 2D02E48C1E0B4A5D006451C7 /* Sources */, + 2D02E48D1E0B4A5D006451C7 /* Frameworks */, + 2D02E48E1E0B4A5D006451C7 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 2D02E4921E0B4A5D006451C7 /* PBXTargetDependency */, + ); + name = "ReactNativeFirebaseDemo-tvOSTests"; + productName = "ReactNativeFirebaseDemo-tvOSTests"; + productReference = 2D02E4901E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOSTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 83CBB9F71A601CBA00E9B192 /* Project object */ = { + isa = PBXProject; + attributes = { + LastUpgradeCheck = 610; + ORGANIZATIONNAME = Facebook; + TargetAttributes = { + 00E356ED1AD99517003FC87E = { + CreatedOnToolsVersion = 6.2; + TestTargetID = 13B07F861A680F5B00A75B9A; + }; + 2D02E47A1E0B4A5D006451C7 = { + CreatedOnToolsVersion = 8.2.1; + ProvisioningStyle = Automatic; + }; + 2D02E48F1E0B4A5D006451C7 = { + CreatedOnToolsVersion = 8.2.1; + ProvisioningStyle = Automatic; + TestTargetID = 2D02E47A1E0B4A5D006451C7; + }; + }; + }; + buildConfigurationList = 83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "ReactNativeFirebaseDemo" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 83CBB9F61A601CBA00E9B192; + productRefGroup = 83CBBA001A601CBA00E9B192 /* Products */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = 997890161E6D86E700F6820C /* Products */; + ProjectRef = 78C4D9D5FCAA43A384C23C35 /* LRDRCTSimpleToast.xcodeproj */; + }, + { + ProductGroup = 00C302A81ABCB8CE00DB3ED1 /* Products */; + ProjectRef = 00C302A71ABCB8CE00DB3ED1 /* RCTActionSheet.xcodeproj */; + }, + { + ProductGroup = 5E91572E1DD0AC6500FF2AA8 /* Products */; + ProjectRef = 5E91572D1DD0AC6500FF2AA8 /* RCTAnimation.xcodeproj */; + }, + { + ProductGroup = 00C302B61ABCB90400DB3ED1 /* Products */; + ProjectRef = 00C302B51ABCB90400DB3ED1 /* RCTGeolocation.xcodeproj */; + }, + { + ProductGroup = 00C302BC1ABCB91800DB3ED1 /* Products */; + ProjectRef = 00C302BB1ABCB91800DB3ED1 /* RCTImage.xcodeproj */; + }, + { + ProductGroup = 78C398B11ACF4ADC00677621 /* Products */; + ProjectRef = 78C398B01ACF4ADC00677621 /* RCTLinking.xcodeproj */; + }, + { + ProductGroup = 00C302D41ABCB9D200DB3ED1 /* Products */; + ProjectRef = 00C302D31ABCB9D200DB3ED1 /* RCTNetwork.xcodeproj */; + }, + { + ProductGroup = 139105B71AF99BAD00B5F7CC /* Products */; + ProjectRef = 139105B61AF99BAD00B5F7CC /* RCTSettings.xcodeproj */; + }, + { + ProductGroup = 832341B11AAA6A8300B99B32 /* Products */; + ProjectRef = 832341B01AAA6A8300B99B32 /* RCTText.xcodeproj */; + }, + { + ProductGroup = 00C302E01ABCB9EE00DB3ED1 /* Products */; + ProjectRef = 00C302DF1ABCB9EE00DB3ED1 /* RCTVibration.xcodeproj */; + }, + { + ProductGroup = 139FDEE71B06529A00C62182 /* Products */; + ProjectRef = 139FDEE61B06529A00C62182 /* RCTWebSocket.xcodeproj */; + }, + { + ProductGroup = 146834001AC3E56700842450 /* Products */; + ProjectRef = 146833FF1AC3E56700842450 /* React.xcodeproj */; + }, + { + ProductGroup = 99788FE61E69DE2900F6820C /* Products */; + ProjectRef = C7C48FEEC8E34DE4BB5DE211 /* RNFirebase.xcodeproj */; + }, + { + ProductGroup = 99788FE81E69DE2900F6820C /* Products */; + ProjectRef = 8BE028F5B04B4DC3BEF0305F /* RNVectorIcons.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + 13B07F861A680F5B00A75B9A /* ReactNativeFirebaseDemo */, + 00E356ED1AD99517003FC87E /* ReactNativeFirebaseDemoTests */, + 2D02E47A1E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOS */, + 2D02E48F1E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOSTests */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + 00C302AC1ABCB8CE00DB3ED1 /* libRCTActionSheet.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTActionSheet.a; + remoteRef = 00C302AB1ABCB8CE00DB3ED1 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00C302BA1ABCB90400DB3ED1 /* libRCTGeolocation.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTGeolocation.a; + remoteRef = 00C302B91ABCB90400DB3ED1 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00C302C01ABCB91800DB3ED1 /* libRCTImage.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTImage.a; + remoteRef = 00C302BF1ABCB91800DB3ED1 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00C302DC1ABCB9D200DB3ED1 /* libRCTNetwork.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTNetwork.a; + remoteRef = 00C302DB1ABCB9D200DB3ED1 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00C302E41ABCB9EE00DB3ED1 /* libRCTVibration.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTVibration.a; + remoteRef = 00C302E31ABCB9EE00DB3ED1 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 139105C11AF99BAD00B5F7CC /* libRCTSettings.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTSettings.a; + remoteRef = 139105C01AF99BAD00B5F7CC /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 139FDEF41B06529B00C62182 /* libRCTWebSocket.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTWebSocket.a; + remoteRef = 139FDEF31B06529B00C62182 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 146834041AC3E56700842450 /* libReact.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libReact.a; + remoteRef = 146834031AC3E56700842450 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3E841DF850E9000B6D8A /* libRCTImage-tvOS.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libRCTImage-tvOS.a"; + remoteRef = 3DAD3E831DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3E881DF850E9000B6D8A /* libRCTLinking-tvOS.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libRCTLinking-tvOS.a"; + remoteRef = 3DAD3E871DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3E8C1DF850E9000B6D8A /* libRCTNetwork-tvOS.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libRCTNetwork-tvOS.a"; + remoteRef = 3DAD3E8B1DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3E901DF850E9000B6D8A /* libRCTSettings-tvOS.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libRCTSettings-tvOS.a"; + remoteRef = 3DAD3E8F1DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3E941DF850E9000B6D8A /* libRCTText-tvOS.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libRCTText-tvOS.a"; + remoteRef = 3DAD3E931DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3E991DF850E9000B6D8A /* libRCTWebSocket-tvOS.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libRCTWebSocket-tvOS.a"; + remoteRef = 3DAD3E981DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3EA31DF850E9000B6D8A /* libReact.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libReact.a; + remoteRef = 3DAD3EA21DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3EA51DF850E9000B6D8A /* libyoga.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libyoga.a; + remoteRef = 3DAD3EA41DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3EA71DF850E9000B6D8A /* libyoga.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libyoga.a; + remoteRef = 3DAD3EA61DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3EA91DF850E9000B6D8A /* libcxxreact.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libcxxreact.a; + remoteRef = 3DAD3EA81DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3EAB1DF850E9000B6D8A /* libcxxreact.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libcxxreact.a; + remoteRef = 3DAD3EAA1DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3EAD1DF850E9000B6D8A /* libjschelpers.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libjschelpers.a; + remoteRef = 3DAD3EAC1DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 3DAD3EAF1DF850E9000B6D8A /* libjschelpers.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libjschelpers.a; + remoteRef = 3DAD3EAE1DF850E9000B6D8A /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 5E9157331DD0AC6500FF2AA8 /* libRCTAnimation.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTAnimation.a; + remoteRef = 5E9157321DD0AC6500FF2AA8 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 5E9157351DD0AC6500FF2AA8 /* libRCTAnimation-tvOS.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libRCTAnimation-tvOS.a"; + remoteRef = 5E9157341DD0AC6500FF2AA8 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 78C398B91ACF4ADC00677621 /* libRCTLinking.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTLinking.a; + remoteRef = 78C398B81ACF4ADC00677621 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 832341B51AAA6A8300B99B32 /* libRCTText.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRCTText.a; + remoteRef = 832341B41AAA6A8300B99B32 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 997890051E69DE2900F6820C /* RNFirebase.framework */ = { + isa = PBXReferenceProxy; + fileType = wrapper.framework; + path = RNFirebase.framework; + remoteRef = 997890041E69DE2900F6820C /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 997890081E69DE2900F6820C /* libRNVectorIcons.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libRNVectorIcons.a; + remoteRef = 997890071E69DE2900F6820C /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 9978901A1E6D86E700F6820C /* libLRDRCTSimpleToast.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libLRDRCTSimpleToast.a; + remoteRef = 997890191E6D86E700F6820C /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXResourcesBuildPhase section */ + 00E356EC1AD99517003FC87E /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 13B07F8E1A680F5B00A75B9A /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8EE7622C1E718A8600B1E0F6 /* GoogleService-Info.plist in Resources */, + 13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */, + 13B07FBD1A68108700A75B9A /* LaunchScreen.xib in Resources */, + EA30CACE4CB84AC1BAE59432 /* Entypo.ttf in Resources */, + F57EC9E3C5414A99821B73F4 /* EvilIcons.ttf in Resources */, + 211A77BD015F4D728A9B6E72 /* FontAwesome.ttf in Resources */, + 1852BC611C674A2E905975BC /* Foundation.ttf in Resources */, + 82FE196A2ADC4D29BB2CB4BF /* Ionicons.ttf in Resources */, + 6F307BC16AD047C8BD921730 /* MaterialCommunityIcons.ttf in Resources */, + 9D2381E3C2D340BA9A0737E2 /* MaterialIcons.ttf in Resources */, + 885057F5D1FA461AAAE0B487 /* Octicons.ttf in Resources */, + 42A0E8F428A74B23B4C7D95A /* SimpleLineIcons.ttf in Resources */, + D46EBD0604CE40EFB18F8A35 /* Zocial.ttf in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 2D02E4791E0B4A5D006451C7 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 2D02E4BD1E0B4A84006451C7 /* Images.xcassets in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 2D02E48E1E0B4A5D006451C7 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "Bundle React Native code and images"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "export NODE_BINARY=node\n../node_modules/react-native/packager/react-native-xcode.sh"; + }; + 26F9B43687A3EAE646F8970D /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "[CP] Check Pods Manifest.lock"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_ROOT}/../Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n"; + showEnvVarsInLog = 0; + }; + 2D02E4CB1E0B4B27006451C7 /* Bundle React Native Code And Images */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "Bundle React Native Code And Images"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "export NODE_BINARY=node\n../node_modules/react-native/packager/react-native-xcode.sh"; + }; + 6AE1012F46FF8A4D1D818A12 /* [CP] Copy Pods Resources */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "[CP] Copy Pods Resources"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"${SRCROOT}/Pods/Target Support Files/Pods-ReactNativeFirebaseDemo/Pods-ReactNativeFirebaseDemo-resources.sh\"\n"; + showEnvVarsInLog = 0; + }; + C015646CE8F8CB4B578CE178 /* [CP] Embed Pods Frameworks */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "[CP] Embed Pods Frameworks"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"${SRCROOT}/Pods/Target Support Files/Pods-ReactNativeFirebaseDemo/Pods-ReactNativeFirebaseDemo-frameworks.sh\"\n"; + showEnvVarsInLog = 0; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 00E356EA1AD99517003FC87E /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00E356F31AD99517003FC87E /* ReactNativeFirebaseDemoTests.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 13B07F871A680F5B00A75B9A /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 13B07FBC1A68108700A75B9A /* AppDelegate.m in Sources */, + 13B07FC11A68108700A75B9A /* main.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 2D02E4771E0B4A5D006451C7 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 2D02E4BF1E0B4AB3006451C7 /* main.m in Sources */, + 2D02E4BC1E0B4A80006451C7 /* AppDelegate.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 2D02E48C1E0B4A5D006451C7 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 2DCD954D1E0B4F2C00145EB5 /* ReactNativeFirebaseDemoTests.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 00E356F51AD99517003FC87E /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 13B07F861A680F5B00A75B9A /* ReactNativeFirebaseDemo */; + targetProxy = 00E356F41AD99517003FC87E /* PBXContainerItemProxy */; + }; + 2D02E4921E0B4A5D006451C7 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 2D02E47A1E0B4A5D006451C7 /* ReactNativeFirebaseDemo-tvOS */; + targetProxy = 2D02E4911E0B4A5D006451C7 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 13B07FB11A68108700A75B9A /* LaunchScreen.xib */ = { + isa = PBXVariantGroup; + children = ( + 13B07FB21A68108700A75B9A /* Base */, + ); + name = LaunchScreen.xib; + path = ReactNativeFirebaseDemo; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 00E356F61AD99517003FC87E /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/../node_modules/react-native-firebase/Firebase.framework/Headers/**", + "$(SRCROOT)/../node_modules/react-native-vector-icons/RNVectorIconsManager", + "$(SRCROOT)/../node_modules/react-native-simple-toast/ios/LRDRCTSimpleToast", + ); + INFOPLIST_FILE = ReactNativeFirebaseDemoTests/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 8.0; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + ); + OTHER_LDFLAGS = ( + "-ObjC", + "-lc++", + ); + PRODUCT_NAME = "$(TARGET_NAME)"; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/ReactNativeFirebaseDemo.app/ReactNativeFirebaseDemo"; + }; + name = Debug; + }; + 00E356F71AD99517003FC87E /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + COPY_PHASE_STRIP = NO; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/../node_modules/react-native-firebase/Firebase.framework/Headers/**", + "$(SRCROOT)/../node_modules/react-native-vector-icons/RNVectorIconsManager", + "$(SRCROOT)/../node_modules/react-native-simple-toast/ios/LRDRCTSimpleToast", + ); + INFOPLIST_FILE = ReactNativeFirebaseDemoTests/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 8.0; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + ); + OTHER_LDFLAGS = ( + "-ObjC", + "-lc++", + ); + PRODUCT_NAME = "$(TARGET_NAME)"; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/ReactNativeFirebaseDemo.app/ReactNativeFirebaseDemo"; + }; + name = Release; + }; + 13B07F941A680F5B00A75B9A /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 07C05CEFA32C3C442CA152DB /* Pods-ReactNativeFirebaseDemo.debug.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CURRENT_PROJECT_VERSION = 1; + DEAD_CODE_STRIPPING = NO; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/../node_modules/react-native-firebase/Firebase.framework/Headers/**", + "$(SRCROOT)/../node_modules/react-native-vector-icons/RNVectorIconsManager", + "$(SRCROOT)/../node_modules/react-native-simple-toast/ios/LRDRCTSimpleToast", + ); + INFOPLIST_FILE = ReactNativeFirebaseDemo/Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; + OTHER_LDFLAGS = ( + "$(inherited)", + "-ObjC", + "-lc++", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.invertase.ReactNativeFirebaseDemo; + PRODUCT_NAME = ReactNativeFirebaseDemo; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Debug; + }; + 13B07F951A680F5B00A75B9A /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 93FF19757985B70080544398 /* Pods-ReactNativeFirebaseDemo.release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CURRENT_PROJECT_VERSION = 1; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/../node_modules/react-native-firebase/Firebase.framework/Headers/**", + "$(SRCROOT)/../node_modules/react-native-vector-icons/RNVectorIconsManager", + "$(SRCROOT)/../node_modules/react-native-simple-toast/ios/LRDRCTSimpleToast", + ); + INFOPLIST_FILE = ReactNativeFirebaseDemo/Info.plist; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; + OTHER_LDFLAGS = ( + "$(inherited)", + "-ObjC", + "-lc++", + ); + PRODUCT_BUNDLE_IDENTIFIER = com.invertase.ReactNativeFirebaseDemo; + PRODUCT_NAME = ReactNativeFirebaseDemo; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Release; + }; + 2D02E4971E0B4A5E006451C7 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = "App Icon & Top Shelf Image"; + ASSETCATALOG_COMPILER_LAUNCHIMAGE_NAME = LaunchImage; + CLANG_ANALYZER_NONNULL = YES; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_TESTABILITY = YES; + GCC_NO_COMMON_BLOCKS = YES; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/../node_modules/react-native-firebase/Firebase.framework/Headers/**", + "$(SRCROOT)/../node_modules/react-native-vector-icons/RNVectorIconsManager", + "$(SRCROOT)/../node_modules/react-native-simple-toast/ios/LRDRCTSimpleToast", + ); + INFOPLIST_FILE = "ReactNativeFirebaseDemo-tvOS/Info.plist"; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + ); + OTHER_LDFLAGS = ( + "-ObjC", + "-lc++", + ); + PRODUCT_BUNDLE_IDENTIFIER = "com.facebook.REACT.ReactNativeFirebaseDemo-tvOS"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = appletvos; + TARGETED_DEVICE_FAMILY = 3; + TVOS_DEPLOYMENT_TARGET = 9.2; + }; + name = Debug; + }; + 2D02E4981E0B4A5E006451C7 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = "App Icon & Top Shelf Image"; + ASSETCATALOG_COMPILER_LAUNCHIMAGE_NAME = LaunchImage; + CLANG_ANALYZER_NONNULL = YES; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_NO_COMMON_BLOCKS = YES; + HEADER_SEARCH_PATHS = ( + "$(inherited)", + "$(SRCROOT)/../node_modules/react-native-firebase/Firebase.framework/Headers/**", + "$(SRCROOT)/../node_modules/react-native-vector-icons/RNVectorIconsManager", + "$(SRCROOT)/../node_modules/react-native-simple-toast/ios/LRDRCTSimpleToast", + ); + INFOPLIST_FILE = "ReactNativeFirebaseDemo-tvOS/Info.plist"; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks"; + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + ); + OTHER_LDFLAGS = ( + "-ObjC", + "-lc++", + ); + PRODUCT_BUNDLE_IDENTIFIER = "com.facebook.REACT.ReactNativeFirebaseDemo-tvOS"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = appletvos; + TARGETED_DEVICE_FAMILY = 3; + TVOS_DEPLOYMENT_TARGET = 9.2; + }; + name = Release; + }; + 2D02E4991E0B4A5E006451C7 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CLANG_ANALYZER_NONNULL = YES; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_TESTABILITY = YES; + GCC_NO_COMMON_BLOCKS = YES; + INFOPLIST_FILE = "ReactNativeFirebaseDemo-tvOSTests/Info.plist"; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + ); + PRODUCT_BUNDLE_IDENTIFIER = "com.facebook.REACT.ReactNativeFirebaseDemo-tvOSTests"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = appletvos; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/ReactNativeFirebaseDemo-tvOS.app/ReactNativeFirebaseDemo-tvOS"; + TVOS_DEPLOYMENT_TARGET = 10.1; + }; + name = Debug; + }; + 2D02E49A1E0B4A5E006451C7 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CLANG_ANALYZER_NONNULL = YES; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_NO_COMMON_BLOCKS = YES; + INFOPLIST_FILE = "ReactNativeFirebaseDemo-tvOSTests/Info.plist"; + LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + "\"$(SRCROOT)/$(TARGET_NAME)\"", + ); + PRODUCT_BUNDLE_IDENTIFIER = "com.facebook.REACT.ReactNativeFirebaseDemo-tvOSTests"; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = appletvos; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/ReactNativeFirebaseDemo-tvOS.app/ReactNativeFirebaseDemo-tvOS"; + TVOS_DEPLOYMENT_TARGET = 10.1; + }; + name = Release; + }; + 83CBBA201A601CBA00E9B192 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_SYMBOLS_PRIVATE_EXTERN = NO; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 8.0; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + }; + name = Debug; + }; + 83CBBA211A601CBA00E9B192 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = YES; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 8.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 00E357021AD99517003FC87E /* Build configuration list for PBXNativeTarget "ReactNativeFirebaseDemoTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 00E356F61AD99517003FC87E /* Debug */, + 00E356F71AD99517003FC87E /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "ReactNativeFirebaseDemo" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 13B07F941A680F5B00A75B9A /* Debug */, + 13B07F951A680F5B00A75B9A /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 2D02E4BA1E0B4A5E006451C7 /* Build configuration list for PBXNativeTarget "ReactNativeFirebaseDemo-tvOS" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 2D02E4971E0B4A5E006451C7 /* Debug */, + 2D02E4981E0B4A5E006451C7 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 2D02E4BB1E0B4A5E006451C7 /* Build configuration list for PBXNativeTarget "ReactNativeFirebaseDemo-tvOSTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 2D02E4991E0B4A5E006451C7 /* Debug */, + 2D02E49A1E0B4A5E006451C7 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 83CBB9FA1A601CBA00E9B192 /* Build configuration list for PBXProject "ReactNativeFirebaseDemo" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 83CBBA201A601CBA00E9B192 /* Debug */, + 83CBBA211A601CBA00E9B192 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 83CBB9F71A601CBA00E9B192 /* Project object */; +} diff --git a/tests/ios/ReactNativeFirebaseDemo.xcodeproj/xcshareddata/xcschemes/ReactNativeFirebaseDemo-tvOS.xcscheme b/tests/ios/ReactNativeFirebaseDemo.xcodeproj/xcshareddata/xcschemes/ReactNativeFirebaseDemo-tvOS.xcscheme new file mode 100644 index 00000000..a5e39259 --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo.xcodeproj/xcshareddata/xcschemes/ReactNativeFirebaseDemo-tvOS.xcscheme @@ -0,0 +1,129 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/ios/ReactNativeFirebaseDemo.xcodeproj/xcshareddata/xcschemes/ReactNativeFirebaseDemo.xcscheme b/tests/ios/ReactNativeFirebaseDemo.xcodeproj/xcshareddata/xcschemes/ReactNativeFirebaseDemo.xcscheme new file mode 100644 index 00000000..8ae9caf0 --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo.xcodeproj/xcshareddata/xcschemes/ReactNativeFirebaseDemo.xcscheme @@ -0,0 +1,129 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/ios/ReactNativeFirebaseDemo/AppDelegate.h b/tests/ios/ReactNativeFirebaseDemo/AppDelegate.h new file mode 100644 index 00000000..a9654d5e --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo/AppDelegate.h @@ -0,0 +1,16 @@ +/** + * Copyright (c) 2015-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ + +#import + +@interface AppDelegate : UIResponder + +@property (nonatomic, strong) UIWindow *window; + +@end diff --git a/tests/ios/ReactNativeFirebaseDemo/AppDelegate.m b/tests/ios/ReactNativeFirebaseDemo/AppDelegate.m new file mode 100644 index 00000000..b7f877eb --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo/AppDelegate.m @@ -0,0 +1,39 @@ +/** + * Copyright (c) 2015-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ + +#import "AppDelegate.h" + +#import +#import +#import + +@implementation AppDelegate + +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions +{ + [FIRApp configure]; + NSURL *jsCodeLocation; + jsCodeLocation = [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index.ios" fallbackResource:nil]; + + RCTRootView *rootView = [[RCTRootView alloc] initWithBundleURL:jsCodeLocation + moduleName:@"ReactNativeFirebaseDemo" + initialProperties:nil + launchOptions:launchOptions]; + + rootView.backgroundColor = [[UIColor alloc] initWithRed:1.0f green:1.0f blue:1.0f alpha:1]; + + self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds]; + UIViewController *rootViewController = [UIViewController new]; + rootViewController.view = rootView; + self.window.rootViewController = rootViewController; + [self.window makeKeyAndVisible]; + return YES; +} + +@end diff --git a/tests/ios/ReactNativeFirebaseDemo/Base.lproj/LaunchScreen.xib b/tests/ios/ReactNativeFirebaseDemo/Base.lproj/LaunchScreen.xib new file mode 100644 index 00000000..5b5d75aa --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo/Base.lproj/LaunchScreen.xib @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Contents.json b/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 00000000..905c43e5 --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,74 @@ +{ + "images" : [ + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-20@2x.png", + "scale" : "2x" + }, + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-20@3x.png", + "scale" : "3x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-29.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-29@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-29@3x.png", + "scale" : "3x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-40@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-40@3x.png", + "scale" : "3x" + }, + { + "size" : "57x57", + "idiom" : "iphone", + "filename" : "Icon-57.png", + "scale" : "1x" + }, + { + "size" : "57x57", + "idiom" : "iphone", + "filename" : "Icon-57@2x.png", + "scale" : "2x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-60@2x.png", + "scale" : "2x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-60@3x.png", + "scale" : "3x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} \ No newline at end of file diff --git a/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-20@2x.png b/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-20@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..e938ca7c6659d348a7dedcf7a38bb8366795c82f GIT binary patch literal 3185 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 literal 0 HcmV?d00001 diff --git a/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-40@3x.png b/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-40@3x.png new file mode 100644 index 0000000000000000000000000000000000000000..280cedd52a82f06921956db48993c46b95fa92e3 GIT binary patch literal 12477 zcmZ{KWl&sAu=e8a?qqR?;4Z;~!{Qo(y99R$?iyGE1Yg`eECdbi4vQ0l1$Qp*zwf(M zw??{VPW7ptGd*XXnSNq4)D*DL$=ppv>Q$1J*6~?6$@9%N0cG3-JLG#rk*DhH z>HWua~B!oe+qPcxNx_xhmA$!l4$ja-s-0&|NiX0x6RA!^x#syGtpCV#YFG zCKtYE0<}U;$!;EA^bd5`J8pGKAX+4n`Al5u;w(ohkH=qbHXLfVOzKel|DUXleQzY* z*6<+P;_Me@;Bg}jx};!|sn@5E1&ZjdJqi9T?y(WugRiMFlz$u(U^RNIh65sj^03C> zR{%Iy@J4yV*tIzeH?HqA_%y z9nImmX%2^1dJyz68i<>M+s2hsgon3lC9O_^ej^$a)Z9|z3B%n{y3Pr4ZDOw>8Dkmm z1U}Sx^lAeS%l(Dzj?mzxzt|26lj}Bt!q6Tx(D?JJ)6lDz7m%Cb8adaE17w>-Lb^I|Y)XP!zlyr!00YDNntggea2H}Zp0aDqh2CO7@WYMXe zSJbKwaKUe2fdPc21)_v^Z9=!2I^t9AdzE|e8*a=05O1;<5jKn4ixv>f5Nisa17M`)6QoIhP=Wweh}0FTl~gq$VBcrXRnpCR$}|341VFCE21Xb8;o87n;IgPA zB68#9?ZCob*ULIK7|s|+!*FIrb4?5G)+7kH)Uk^6glN=xR8Q^G2r;Eg-6X_gsW@s3 zB{CQ~796BILzbXKjC7dc)6@V*G}X3Q%whaE-Sgq!iq+8BV~2%9do9Im0Bs0u#CKTd z$xv)re4RM^zCh}8Wmq~m=qGUsuM}HoI%?9-Dy#RlZ%&rQ@xe)@i}3E9MvW*X!kN~5 zt&~>LGCK19sW^K1IsFPmu1mVMnR*+mI~{R1Gpq%w{ljh zFETYX2G~EmO3%e$pI}RxrUM9qaQOtgesU;y%!mxBeD;P4MWSj7-L+r-1r94?a|nXF$O&->G~t!vud&S-UGx2oCZ{lR8=+6d10i1d4Gui5Vy>S!&K=D~WF>SmbXMouBYO)TtXi?f*|gb* zm!)w?x}y1vdH3-b%OiXg0)4K(5o2g3TAOuyAKwfaR@5sq&_OPu1patLhoz{V?V+KnPiqJH%> z6nkKuT_ff)MS1G@$Ni1Lg%8Ptb?QCbA`7{?m|>$( zb#tRqd3L~0>W*cY60fv>7@*FJ>23&B6Wd##-|F@bhA3!@A60#HtW{K*?7+YF>90VS5>`iBNa(^GQC3TE<-tqNfRI zoB&nXjnHpOXyJWx7>m{ssJyOoMg52J87$ImkFBJS^S1Z8j`S-y%emz}G+^3+bLpNy zbIXnr_d5AM!vx)_&Ncl(4zEr#1}oodR%1K~jdqQ6akbKmx1@$oeapOJ7OH!Hl$R&$ zq@WsJYx$j3#z4Yxh5AQS5@shqD*U@MH)YZqHaP3f+ioI z2kLg6I?|U4m8m`6`R|*¨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 literal 0 HcmV?d00001 diff --git a/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-57@2x.png b/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-57@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..302d009f00bd2272190fd7d9113023677938dad8 GIT binary patch literal 11757 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 literal 0 HcmV?d00001 diff --git a/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-60@2x.png b/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/AppIcon.appiconset/Icon-60@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..280cedd52a82f06921956db48993c46b95fa92e3 GIT binary patch literal 12477 zcmZ{KWl&sAu=e8a?qqR?;4Z;~!{Qo(y99R$?iyGE1Yg`eECdbi4vQ0l1$Qp*zwf(M zw??{VPW7ptGd*XXnSNq4)D*DL$=ppv>Q$1J*6~?6$@9%N0cG3-JLG#rk*DhH z>HWua~B!oe+qPcxNx_xhmA$!l4$ja-s-0&|NiX0x6RA!^x#syGtpCV#YFG zCKtYE0<}U;$!;EA^bd5`J8pGKAX+4n`Al5u;w(ohkH=qbHXLfVOzKel|DUXleQzY* z*6<+P;_Me@;Bg}jx};!|sn@5E1&ZjdJqi9T?y(WugRiMFlz$u(U^RNIh65sj^03C> zR{%Iy@J4yV*tIzeH?HqA_%y z9nImmX%2^1dJyz68i<>M+s2hsgon3lC9O_^ej^$a)Z9|z3B%n{y3Pr4ZDOw>8Dkmm z1U}Sx^lAeS%l(Dzj?mzxzt|26lj}Bt!q6Tx(D?JJ)6lDz7m%Cb8adaE17w>-Lb^I|Y)XP!zlyr!00YDNntggea2H}Zp0aDqh2CO7@WYMXe zSJbKwaKUe2fdPc21)_v^Z9=!2I^t9AdzE|e8*a=05O1;<5jKn4ixv>f5Nisa17M`)6QoIhP=Wweh}0FTl~gq$VBcrXRnpCR$}|341VFCE21Xb8;o87n;IgPA zB68#9?ZCob*ULIK7|s|+!*FIrb4?5G)+7kH)Uk^6glN=xR8Q^G2r;Eg-6X_gsW@s3 zB{CQ~796BILzbXKjC7dc)6@V*G}X3Q%whaE-Sgq!iq+8BV~2%9do9Im0Bs0u#CKTd z$xv)re4RM^zCh}8Wmq~m=qGUsuM}HoI%?9-Dy#RlZ%&rQ@xe)@i}3E9MvW*X!kN~5 zt&~>LGCK19sW^K1IsFPmu1mVMnR*+mI~{R1Gpq%w{ljh zFETYX2G~EmO3%e$pI}RxrUM9qaQOtgesU;y%!mxBeD;P4MWSj7-L+r-1r94?a|nXF$O&->G~t!vud&S-UGx2oCZ{lR8=+6d10i1d4Gui5Vy>S!&K=D~WF>SmbXMouBYO)TtXi?f*|gb* zm!)w?x}y1vdH3-b%OiXg0)4K(5o2g3TAOuyAKwfaR@5sq&_OPu1patLhoz{V?V+KnPiqJH%> z6nkKuT_ff)MS1G@$Ni1Lg%8Ptb?QCbA`7{?m|>$( zb#tRqd3L~0>W*cY60fv>7@*FJ>23&B6Wd##-|F@bhA3!@A60#HtW{K*?7+YF>90VS5>`iBNa(^GQC3TE<-tqNfRI zoB&nXjnHpOXyJWx7>m{ssJyOoMg52J87$ImkFBJS^S1Z8j`S-y%emz}G+^3+bLpNy zbIXnr_d5AM!vx)_&Ncl(4zEr#1}oodR%1K~jdqQ6akbKmx1@$oeapOJ7OH!Hl$R&$ zq@WsJYx$j3#z4Yxh5AQS5@shqD*U@MH)YZqHaP3f+ioI z2kLg6I?|U4m8m`6`R|*¨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 aCwG^S|2trIyy!J80HCjJOf#~26#XBFb6ZIO literal 0 HcmV?d00001 diff --git a/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/Contents.json b/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/Contents.json new file mode 100644 index 00000000..da4a164c --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo/Images.xcassets/Contents.json @@ -0,0 +1,6 @@ +{ + "info" : { + "version" : 1, + "author" : "xcode" + } +} \ No newline at end of file diff --git a/tests/ios/ReactNativeFirebaseDemo/Info.plist b/tests/ios/ReactNativeFirebaseDemo/Info.plist new file mode 100644 index 00000000..f764dd7f --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo/Info.plist @@ -0,0 +1,66 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1 + LSRequiresIPhoneOS + + NSAppTransportSecurity + + NSExceptionDomains + + localhost + + NSExceptionAllowsInsecureHTTPLoads + + + + + NSLocationWhenInUseUsageDescription + + UIAppFonts + + Entypo.ttf + EvilIcons.ttf + FontAwesome.ttf + Foundation.ttf + Ionicons.ttf + MaterialCommunityIcons.ttf + MaterialIcons.ttf + Octicons.ttf + SimpleLineIcons.ttf + Zocial.ttf + + UILaunchStoryboardName + LaunchScreen + UIRequiredDeviceCapabilities + + armv7 + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UIViewControllerBasedStatusBarAppearance + + + diff --git a/tests/ios/ReactNativeFirebaseDemo/main.m b/tests/ios/ReactNativeFirebaseDemo/main.m new file mode 100644 index 00000000..3d767fcb --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemo/main.m @@ -0,0 +1,18 @@ +/** + * Copyright (c) 2015-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ + +#import + +#import "AppDelegate.h" + +int main(int argc, char * argv[]) { + @autoreleasepool { + return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class])); + } +} diff --git a/tests/ios/ReactNativeFirebaseDemoTests/Info.plist b/tests/ios/ReactNativeFirebaseDemoTests/Info.plist new file mode 100644 index 00000000..886825cc --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemoTests/Info.plist @@ -0,0 +1,24 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + org.reactjs.native.example.$(PRODUCT_NAME:rfc1034identifier) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + BNDL + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1 + + diff --git a/tests/ios/ReactNativeFirebaseDemoTests/ReactNativeFirebaseDemoTests.m b/tests/ios/ReactNativeFirebaseDemoTests/ReactNativeFirebaseDemoTests.m new file mode 100644 index 00000000..fd9d570c --- /dev/null +++ b/tests/ios/ReactNativeFirebaseDemoTests/ReactNativeFirebaseDemoTests.m @@ -0,0 +1,70 @@ +/** + * Copyright (c) 2015-present, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ + +#import +#import + +#import +#import + +#define TIMEOUT_SECONDS 600 +#define TEXT_TO_LOOK_FOR @"Welcome to React Native!" + +@interface ReactNativeFirebaseDemoTests : XCTestCase + +@end + +@implementation ReactNativeFirebaseDemoTests + +- (BOOL)findSubviewInView:(UIView *)view matching:(BOOL(^)(UIView *view))test +{ + if (test(view)) { + return YES; + } + for (UIView *subview in [view subviews]) { + if ([self findSubviewInView:subview matching:test]) { + return YES; + } + } + return NO; +} + +- (void)testRendersWelcomeScreen +{ + UIViewController *vc = [[[[UIApplication sharedApplication] delegate] window] rootViewController]; + NSDate *date = [NSDate dateWithTimeIntervalSinceNow:TIMEOUT_SECONDS]; + BOOL foundElement = NO; + + __block NSString *redboxError = nil; + RCTSetLogFunction(^(RCTLogLevel level, RCTLogSource source, NSString *fileName, NSNumber *lineNumber, NSString *message) { + if (level >= RCTLogLevelError) { + redboxError = message; + } + }); + + while ([date timeIntervalSinceNow] > 0 && !foundElement && !redboxError) { + [[NSRunLoop mainRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]]; + [[NSRunLoop mainRunLoop] runMode:NSRunLoopCommonModes beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.1]]; + + foundElement = [self findSubviewInView:vc.view matching:^BOOL(UIView *view) { + if ([view.accessibilityLabel isEqualToString:TEXT_TO_LOOK_FOR]) { + return YES; + } + return NO; + }]; + } + + RCTSetLogFunction(RCTDefaultLogFunction); + + XCTAssertNil(redboxError, @"RedBox error: %@", redboxError); + XCTAssertTrue(foundElement, @"Couldn't find element with text '%@' in %d seconds", TEXT_TO_LOOK_FOR, TIMEOUT_SECONDS); +} + + +@end diff --git a/tests/lib/RunStatus.js b/tests/lib/RunStatus.js new file mode 100644 index 00000000..daf27d52 --- /dev/null +++ b/tests/lib/RunStatus.js @@ -0,0 +1,5 @@ +module.exports = { + RUNNING: 'running', + OK: 'success', + ERR: 'error', +}; diff --git a/tests/lib/TestDSL.js b/tests/lib/TestDSL.js new file mode 100644 index 00000000..bbdd5502 --- /dev/null +++ b/tests/lib/TestDSL.js @@ -0,0 +1,251 @@ +/** + * Class that provides DSL for declaratively defining tests. Provides a declarative + * interface for {@link TestSuiteDefinition} and only reveals methods that are part + * of the test definition DSL. + */ +class TestDSL { + /** + * Create a new instance of TestDSL + * @param {TestSuiteDefinition} testSuiteDefinition - Class to delegate the heavy lifting + * of satisfying the DSL, to. + * @param {Object} firebase - Object containing native and web firebase instances + * @param {Object} firebase.native - Native firebase instance + * @para {Object} firebase.web - Web firebase instance + */ + constructor(testSuiteDefinition, firebase) { + this._testSuiteDefinition = testSuiteDefinition; + + this.firebase = firebase; + + this.after = this.after.bind(this); + this.afterEach = this.afterEach.bind(this); + + this.before = this.before.bind(this); + this.beforeEach = this.beforeEach.bind(this); + + this.describe = this.describe.bind(this); + /** Alias for {@link TestDSL#describe } */ + this.context = this.describe; + this.fdescribe = this.fdescribe.bind(this); + /** Alias for {@link TestDSL#fdescribe } */ + this.fcontext = this.fdescribe; + this.xdescribe = this.xdescribe.bind(this); + /** Alias for {@link TestDSL#xdescribe } */ + this.xcontext = this.xdescribe; + + this.tryCatch = this.tryCatch.bind(this); + + this.it = this.it.bind(this); + this.xit = this.xit.bind(this); + this.fit = this.fit.bind(this); + } + + /** + * Add a function as a before hook to the current test context + * @param {Object=} options - Options object + * @param {Number=10000} options.timeout - Number of milliseconds before callback times + * out + * @param {Function} callback - Function to add as before hook to current test context + */ + before(options, callback = undefined) { + const _options = callback ? options : {}; + const _callback = callback || options; + + this._testSuiteDefinition.addBeforeHook(_callback, _options); + } + + /** + * Add a function as a before each hook to the current test context + * @param {Object=} options - Options object + * @param {Number=10000} options.timeout - Number of milliseconds before callback times + * out + * @param {Function} callback - Function to add as before each hook to current test + * context + */ + beforeEach(options, callback = undefined) { + const _options = callback ? options : {}; + const _callback = callback || options; + + this._testSuiteDefinition.addBeforeEachHook(_callback, _options); + } + + /** + * Add a function as a after each hook to the current test context + * @param {Object=} options - Options object + * @param {Number=10000} options.timeout - Number of milliseconds before callback times + * out + * @param {Function} callback - Function to add as after each hook to current test context + */ + afterEach(options, callback = undefined) { + const _options = callback ? options : {}; + const _callback = callback || options; + + this._testSuiteDefinition.addAfterEachHook(_callback, _options); + } + + /** + * Add a function as a after hook to the current test context + * @param {Object=} options - Options object + * @param {Number=10000} options.timeout - Number of milliseconds before callback times + * out + * @param {Function} callback - Function to add as after hook to current test context + */ + after(options, callback = undefined) { + const _options = callback ? options : {}; + const _callback = callback || options; + + this._testSuiteDefinition.addAfterHook(_callback, _options); + } + + /** + * Starts a new test context + * @param {String} name - name of new test context + * @param {ContextOptions} options - options for context + * @param {Function} [testDefinitions={}] - function that defines further test contexts and + * tests using the test DSL + */ + describe(name, options, testDefinitions) { + let _testDefinitions; + let _options; + + if (testDefinitions) { + _testDefinitions = testDefinitions; + _options = options; + } else { + _testDefinitions = options; + _options = {}; + } + + this._testSuiteDefinition.pushTestContext(name, _options); + _testDefinitions(); + this._testSuiteDefinition.popTestContext(); + } + + /** + * Starts a new pending test context. Tests in a pending test context are not + * run when the test suite is executed. They also appear greyed out. + * @param {String} name - name of new test context + * @param {ContextOptions} [options={}] - options for context + * @param {Function} testDefinitions - function that defines further test contexts and + * tests using the test DSL + */ + xdescribe(name, options, testDefinitions = undefined) { + let _options = {}; + let _testDefinitions; + + if (typeof options === 'function') { + _options = { pending: true }; + _testDefinitions = options; + } else { + Object.assign(_options, options, { pending: true }); + _testDefinitions = testDefinitions; + } + + this.describe(name, _options, _testDefinitions); + } + + /** + * Starts a new focused test context. Tests in a focused test context are the only + * ones that appear and are run when the test suite is executed. + * @param {String} name - name of new test context + * @param {ContextOptions} [options={}] - options for context + * @param {Function} testDefinitions - function that defines further test contexts and + * tests using the test DSL + */ + fdescribe(name, options, testDefinitions = undefined) { + let _options = {}; + let _testDefinitions; + + if (typeof options === 'function') { + _options = { focus: true }; + _testDefinitions = options; + } else { + Object.assign(_options, options, { focus: true }); + _testDefinitions = testDefinitions; + } + + this.describe(name, _options, _testDefinitions); + } + + /** + * Defines a new test. + * @param {String} description - Brief description of what the test expects + * @param {TestOptions} options - Options of whether test should be focused or pending + * @param {Function} testFunction - Body of the test containing setup and assertions + */ + it(description, options, testFunction = undefined) { + this._testSuiteDefinition.addTest(description, options, testFunction); + } + + /** + * Defines a new pending test. Pending tests are not run when the test suite is + * executed. They also appear greyed out. + * @param {String} description - Brief description of what the test expects + * @param {ContextOptions} [options={}] - Options of whether test should be focused or pending + * @param {Function} testFunction - Body of the test containing setup and assertions + */ + xit(description, options, testFunction = undefined) { + let _options = {}; + let _testFunction; + + if (typeof options === 'function') { + _options = { pending: true }; + _testFunction = options; + } else { + Object.assign(_options, options, { pending: true }); + _testFunction = testFunction; + } + + this.it(description, _options, _testFunction); + } + + + /** + * Defines a new focused test. Focused tests are the only + * ones that appear and are run when the test suite is executed. + * @param {String} description - Brief description of what the test expects + * @param {ContextOptions} [options={}] - Options of whether test should be focused or pending + * @param {Function} testFunction - Body of the test containing setup and assertions + */ + fit(description, options, testFunction = undefined) { + let _options = {}; + let _testFunction; + + if (typeof options === 'function') { + _options = { focus: true }; + _testFunction = options; + } else { + Object.assign(_options, options, { focus: true }); + _testFunction = testFunction; + } + + this.it(description, _options, _testFunction); + } + + /** + * Tries evaluating a function and calls a reject callback if it throws an error + * @param {Function} callback - Function to evaluate + * @param {Function} reject - Function to call if callback throws an error + * @returns {function(...[*])} a function that will catch any errors thrown by callback, + * passing them to reject instead. + */ + tryCatch(callback, reject) { + return (...args) => { + try { + callback(...args); + } catch (error) { + reject(error); + } + }; + } +} + +/** + * Log a test DSL error to the console. + * @param {String} error - Message to included in message logged to the console + */ +function testDSLError(error) { + console.error(`ReactNativeFirebaseTests.TestDSLError: ${error}`); + console.error('This test was ignored.'); +} +export default TestDSL; diff --git a/tests/lib/TestRun.js b/tests/lib/TestRun.js new file mode 100644 index 00000000..c927949d --- /dev/null +++ b/tests/lib/TestRun.js @@ -0,0 +1,386 @@ +import Promise from 'bluebird'; +import RunStatus from './RunStatus'; + +const EVENTS = { + TEST_SUITE_STATUS: 'TEST_SUITE_STATUS', + TEST_STATUS: 'TEST_STATUS', +}; + +/** + * Class that encapsulates synchronously running a suite's tests. + */ +class TestRun { + /** + * The number of tests that have been executed so far + * @type {number} + */ + completedTests = 0; + + /** + * Creates a new TestRun + * @param {TestSuite} testSuite - Test suite that tests belong to + * @param {Test[]} tests - List of test to run + * @param {TestSuiteDefinition} testDefinitions - Definition of tests and contexts + */ + constructor(testSuite, tests, testDefinitions) { + this.testSuite = testSuite; + + this.tests = tests; + + this.rootContextId = testDefinitions.rootTestContextId; + + this.testContexts = tests.reduce((memo, test) => { + const testContextId = test.testContextId; + + this._recursivelyAddContextsTo(memo, testContextId, testDefinitions.testContexts); + + memo[testContextId].tests.unshift(test); + + return memo; + }, {}); + + this.listeners = { + [EVENTS.TEST_STATUS]: [], + [EVENTS.TEST_SUITE_STATUS]: [], + }; + } + + /** + * Registers a listener for a change event + * @param {String} action - one of the actions in EVENTS + * @param {Function} callback - Callback that accepts event object + */ + onChange(action, callback) { + this.listeners[action].push(callback); + } + + /** + * Walks up a context tree, copying test contexts from a source object to a target one. + * Used for ensuring all of a test's parent contexts are added to the target object. + * @param {Object} target - Object to put test contexts in + * @param {Number} id - Id of current context to add to target + * @param {Object} source - Object to get complete list of test contexts + * from. + * @param {Number} childContextId - id of child of current context + * @private + */ + _recursivelyAddContextsTo(target, id, source, childContextId = null) { + const testContext = source[id]; + + if (!target[id]) { + // eslint-disable-next-line no-param-reassign + target[id] = { + ...testContext, + tests: [], + childContextIds: {}, + }; + } + + if (childContextId) { + // eslint-disable-next-line no-param-reassign + target[id].childContextIds[childContextId] = true; + } + + const parentContextId = testContext.parentContextId; + + if (parentContextId) { + this._recursivelyAddContextsTo(target, parentContextId, source, id); + } + } + + _updateStatus(action, values) { + const listeners = this.listeners[action]; + + listeners.forEach(listener => listener(values)); + } + + /** + * Execute the tests TestRun was initialised with. + * @returns {Promise.} Resolves once all the tests in the test suite have + * completed running. + */ + async execute() { + const store = this.testSuite.reduxStore; + + if (!store) { + testRuntimeError(`Failed to run ${this.testSuite.name} tests as no Redux store has been provided`); + } + + this._updateStatus(EVENTS.TEST_SUITE_STATUS, { + suiteId: this.testSuite.id, + status: RunStatus.RUNNING, + + progress: 0, + time: 0, + }); + + // Start timing + + this.runStartTime = Date.now(); + + const rootContext = this.testContexts[this.rootContextId]; + + if (rootContext) { + await this._runTestsInContext(rootContext); + + const errors = this.tests.filter(test => test.status === RunStatus.ERR); + + if (errors.length) { + this._updateStatus(EVENTS.TEST_SUITE_STATUS, { + suiteId: this.testSuite.id, + status: RunStatus.ERR, + progress: 100, + + time: Date.now() - this.runStartTime, + message: `${errors.length} test${errors.length > 1 ? 's' : ''} has error(s).`, + }); + } else { + this._updateStatus(EVENTS.TEST_SUITE_STATUS, ({ + suiteId: this.testSuite.id, + status: RunStatus.OK, + progress: 100, + + time: Date.now() - this.runStartTime, + message: '', + })); + } + } + } + + /** + * Recursively enter a test context and run its before, beforeEach hooks where + * appropriate; execute the test and then run afterEach and after hooks where + * appropriate. + * @param {TestContext} testContext - context to run hooks for + * @param {Function[][]} beforeEachHooks - stack of beforeEach hooks defined + * in parent contexts that should be run beforeEach test in child contexts + * @param {Function[][]} afterEachHooks - stack of afterEach hooks defined + * in parent contexts that should be run afterEach test in child contexts + * @returns {Promise.} Resolves once all tests and their hooks have run + * @private + */ + async _runTestsInContext(testContext, beforeEachHooks = [], afterEachHooks = []) { + const beforeHookRan = await this._runContextHooks(testContext, 'before'); + + if (beforeHookRan) { + beforeEachHooks.push(testContext.beforeEachHooks || []); + afterEachHooks.unshift(testContext.afterEachHooks || []); + + await this._runTests(testContext, testContext.tests, flatten(beforeEachHooks), flatten(afterEachHooks)); + + await Promise.each(Object.keys(testContext.childContextIds), (childContextId) => { + const childContext = this.testContexts[childContextId]; + return this._runTestsInContext(childContext, beforeEachHooks, afterEachHooks); + }); + + beforeEachHooks.pop(); + afterEachHooks.shift(); + + await this._runContextHooks(testContext, 'after'); + } + } + + /** + * Synchronously run hooks in context's (before|after) hooks, starting from the first + * hook + * @param {TestContext} testContext - context containing hooks + * @param {('before'|'after')} hookName - name of hooks to run callbacks for + * @returns {Promise.<*>} Resolves when last hook in list has been executed + * @private + */ + async _runContextHooks(testContext, hookName) { + const hooks = testContext[`${hookName}Hooks`] || []; + + return this._runHookChain(null, Date.now(), testContext, hookName, hooks); + } + + _runHookChain(test, testStart, testContext, hookName, hooks) { + return Promise.each(hooks, async (hook) => { + const error = await this._safelyRunFunction(hook.callback, hook.timeout, `${hookName} hook`); + + if (error) { + const errorPrefix = `Error occurred in "${testContext.name}" ${hookName} Hook: `; + + if (test) { + this._reportTestError(test, error, Date.now() - testStart, errorPrefix); + } else { + this._reportAllTestsAsFailed(testContext, error, testStart, errorPrefix); + } + + throw new Error(); + } + }).then(() => true).catch(() => false); + } + + _reportAllTestsAsFailed(testContext, error, testStart, errorPrefix) { + testContext.tests.forEach((test) => { + this._reportTestError(test, error, Date.now() - testStart, errorPrefix); + }); + + testContext.childContextIds.forEach((contextId) => { + this._reportAllTestsAsFailed(this.testContext[contextId], error, testStart, errorPrefix); + }); + } + + /** + * Synchronously run a list of tests + * @param {TestContext} testContext - Test context to run beforeEach and AfterEach hooks + * for + * @param {Test[]} tests - List of tests to run + * @param {Function[]} beforeEachHooks - list of functions to run before each test + * @param {Function[]} afterEachHooks - list of functions to run after each test + * @returns {Promise.} - Resolves once all tests and their afterEach hooks have + * been run + * @private + */ + async _runTests(testContext, tests, beforeEachHooks, afterEachHooks) { + return Promise.each(tests, async (test) => { + this._updateStatus(EVENTS.TEST_STATUS, { + testId: test.id, + status: RunStatus.RUNNING, + time: 0, + message: '', + }); + + const testStart = Date.now(); + + const beforeEachRan = await this._runHookChain(test, testStart, testContext, 'beforeEach', beforeEachHooks); + + if (beforeEachRan) { + const error = await this._safelyRunFunction(test.func.bind(null, [test, this.testSuite.reduxStore.getState()]), test.timeout, 'Test'); + + // Update test status + + if (error) { + this._reportTestError(test, error, Date.now() - testStart); + } else { + // eslint-disable-next-line no-param-reassign + test.status = RunStatus.OK; + + this._updateStatus(EVENTS.TEST_STATUS, { + testId: test.id, + status: RunStatus.OK, + time: Date.now() - testStart, + message: '', + }); + } + + // Update suite progress + + this.completedTests += 1; + + this._updateStatus(EVENTS.TEST_SUITE_STATUS, { + suiteId: this.testSuite.id, + status: RunStatus.RUNNING, + progress: (this.completedTests / this.tests.length) * 100, + time: Date.now() - this.runStartTime, + message: '', + }); + + await this._runHookChain(test, testStart, testContext, 'afterEach', afterEachHooks); + } + }) + + .catch((error) => { + this._updateStatus(EVENTS.TEST_SUITE_STATUS, { + suiteId: this.testSuite.id, + status: RunStatus.ERR, + time: Date.now() - this.runStartTime, + message: `Test suite failed: ${error.message}`, + stackTrace: error.stack, + }); + }); + } + + _reportTestError(test, error, time, errorPrefix = '') { + // eslint-disable-next-line no-param-reassign + test.status = RunStatus.ERR; + + this._updateStatus(EVENTS.TEST_STATUS, { + testId: test.id, + status: RunStatus.ERR, + time, + message: `${errorPrefix}${error.message ? `${error.name}: ${error.message}` : error}`, + stackTrace: error.stack, + }); + } + + async _safelyRunFunction(func, timeOutDuration, description) { + const syncResultOrPromise = tryCatcher(func); + + if (syncResultOrPromise.error) { + // Synchronous Error + return syncResultOrPromise.error; + } + + // Asynchronous Error + return promiseToCallBack(syncResultOrPromise.value, timeOutDuration, description); + } + +} + +/** + * Try catch to object + * @returns {{}} + * @private + */ + +function tryCatcher(func) { + const result = {}; + + try { + result.value = func(); + } catch (e) { + result.error = e; + } + + return result; +} + +/** + * Make a promise callback-able to trap errors + * @param promise + * @private + */ + +function promiseToCallBack(promise, timeoutDuration, description) { + let returnValue = null; + + try { + returnValue = Promise.resolve(promise) + .then(() => { + return null; + }, (error) => { + return Promise.resolve(error); + }) + .timeout(timeoutDuration, `${description} took longer than ${timeoutDuration}ms. This can be extended with the timeout option.`) + .catch((error) => { + return Promise.resolve(error); + }); + } catch (error) { + returnValue = Promise.resolve(error); + } + + return returnValue; +} + +/** + * Flatten a two dimensional array to a single dimensional array + * @param {*[]} list - two dimensional array + * @returns {*[]} One-dimensional array + */ +function flatten(list) { + return list.reduce((memo, contextHooks) => { + return memo.concat(contextHooks); + }, []); +} + +/** + * Log a runtime error to the console + * @param {String} error - Message to log to the console + */ +function testRuntimeError(error) { + console.error(`ReactNativeFirebaseTests.TestRuntimeError: ${error}`); +} + +export default TestRun; diff --git a/tests/lib/TestSuite.js b/tests/lib/TestSuite.js new file mode 100644 index 00000000..3924bb8b --- /dev/null +++ b/tests/lib/TestSuite.js @@ -0,0 +1,148 @@ +import 'should'; +import 'should-sinon'; + +import TestSuiteDefinition from './TestSuiteDefinition'; +import TestRun from './TestRun'; + +/** + * Incrementing counter to assign each test suite a globally unique id. Should be + * accessed only through assignTestSuiteId + * @type {number} Counter that maintains globally unique id and increments each time + * a new id is assigned + */ +let testSuiteCounter = 0; + +/** + * Increment the testSuiteCounter and return the new value. Used + * for assigning a new globally unique id to a test suite. + * @returns {number} globally unique id assigned to each test suite + */ +function assignTestSuiteId() { + testSuiteCounter += 1; + return testSuiteCounter; +} + +/** + * Class that provides imperative interface for constructing and running a test suite. + * Used for instantiating a new test suite, adding tests to it and then running all or + * a subset of those tests. + * + * @example + * // Creates a new test suite + * const testSuit = new TestSuite('Feature Group A', 'Feature a, b and c'); + */ +class TestSuite { + /** + * Creates a new test suite. + * @param {String} name - The name of the test suite + * @param {String} description - A short description of the test suite + * @param {Object} firebase - Object containing native and web firebase instances + * @param {Object} firebase.native - Native firebase instance + * @para {Object} firebase.web - Web firebase instance + */ + constructor(name, description, firebase) { + this.id = assignTestSuiteId(); + this.name = name; + this.description = description; + + this.reduxStore = null; + this.testDefinitions = new TestSuiteDefinition(this, firebase); + } + + /** + * @typedef {Function} TestDefinitionFunction + * @param {TestDSL} testDSL - class instance that defines the testing DSL that can + * be used in defining tests + */ + + /** + * Adds tests defined in a function to the test suite + * @param {TestDefinitionFunction} testDefinition - A function that defines one or + * more test suites using the test DSL. + * @example + * // Adding tests + * const testDefinition = function({ describe, it }) { + * describe('Some context', () => { + * it('then does something', () => { + * // Test assertions here + * }) + * }) + * testSuite.addTests(testDefinition); + */ + addTests(testDefinition) { + testDefinition(this.testDefinitions.DSL); + } + + /** + * @typedef {Object} ReduxStore + * @property {Function} getState - Returns the current state of the store + * @property {Function} dispatch - Dispatches a new action to update to store + */ + + /** + * Sets the redux store assigned to the test suite + * @param {ReduxStore} store - The redux store to add to the test suite + * @param {Function} testSuiteAction - Function that accepts an object of + * event values and returns another that is suitable to dispatch to the + * redux store. Responsible for handling events when the test suite's status + * has changed. + * @param {Function} testAction - Function that accepts an object of + * event values and returns another that is suitable to dispatch to the + * redux store. Responsible for handling events when a test's status + * has changed. + */ + setStore(store, testSuiteAction, testAction) { + this.reduxStore = store; + this.suiteChangHandler = testSuiteAction; + this.testChangHandler = testAction; + } + + /** + * Run all the tests matching an array of ids. If the array is not provided, run all + * test in the test suite. + * @param {number[]=} testIds - array of ids for tests to run + * @throws {RangeError} testIds must correspond with tests in the test suite + * @example + * // Running all tests in the test suite + * testSuite.run(); + * @example + * // Run only tests with id 1 and 2 + * testSuite.run([1, 2]); + */ + async run(testIds = undefined) { + const testsToRun = (() => { + if (testIds) { + return testIds.map((id) => { + const test = this.testDefinitions.tests[id]; + + if (!test) { + throw new RangeError(`ReactNativeFirebaseTests.TestRunError: Test with id ${id} not found in test suite ${this.name}`); + } + + return test; + }); + } + + return Object.values(this.testDefinitions.tests); + })(); + + const testRun = new TestRun(this, testsToRun.reverse(), this.testDefinitions); + + testRun.onChange('TEST_SUITE_STATUS', (values) => { + if (this.suiteChangHandler) { + this.suiteChangHandler(values); + } + }); + + testRun.onChange('TEST_STATUS', (values) => { + if (this.testChangHandler) { + this.testChangHandler(values); + } + }); + + await testRun.execute(); + } + +} + +export default TestSuite; diff --git a/tests/lib/TestSuiteDefinition.js b/tests/lib/TestSuiteDefinition.js new file mode 100644 index 00000000..1ebc9aea --- /dev/null +++ b/tests/lib/TestSuiteDefinition.js @@ -0,0 +1,360 @@ +import TestDSL from './TestDSL'; + +/** + * Incrementing counter to assign each test context a globally unique id. + * @type {number} Counter that maintains globally unique id and increments each time + * a new id is assigned + */ +let testContextCounter = 0; + +/** + * Incrementing counter to assign each test a globally unique id. + * @type {number} Counter that maintains globally unique id and increments each time + * a new id is assigned + */ +let testCounter = 0; + +/** + * Increment the testCounter and return the new value. Used + * for assigning a new globally unique id to a test. + * @returns {number} globally unique id assigned to each test + */ +function assignTestId() { + testCounter += 1; + return testCounter; +} + +/** + * Increment the testContextCounter and return the new value. Used + * for assigning a new globally unique id to a test context. + * @returns {number} globally unique id assigned to each test context + */ +function assignContextId() { + testContextCounter += 1; + return testContextCounter; +} + +/** + * Enum for operators that can be used when combining test properties with their + * parents at definition time. + * @readonly + * @enum {String} ContextOperator + */ +const CONTEXT_OPERATORS = { + /** Perform OR of test value with context chain values **/ + OR: 'OR', +}; + +/** + * Class that provides imperative interface for defining tests. When defining tests + * the declarative interface for this class, {@link TestDSL} should be use instead. + */ +class TestSuiteDefinition { + /** + * Creates a new TestSuiteDefinition + * @param {TestSuite} testSuite - The {@link TestSuite} instance for which to + * define tests for. + * @param {Object} firebase - Object containing native and web firebase instances + * @param {Object} firebase.native - Native firebase instance + * @para {Object} firebase.web - Web firebase instance + */ + constructor(testSuite, firebase) { + this.testSuite = testSuite; + + this.tests = {}; + this.pendingTestIds = {}; + this.focusedTestIds = {}; + + this.testContexts = {}; + + this.rootTestContextId = assignContextId(); + this.rootTestContext = this._initialiseContext(this.rootTestContextId, { + name: '', + focus: false, + pending: false, + parentContextId: null, + }); + + this.currentTestContext = this.rootTestContext; + + this._testDSL = new TestDSL(this, firebase); + } + + /** + * Get the instance of {@link TestDSL} used for declaratively defining tests + * @returns {TestDSL} The TestDSL used for defining tests + */ + get DSL() { + return this._testDSL; + } + + /** + * Add a function as a before hook to the current test context + * @param {Function} callback - Function to add as before hook to current test context + */ + addBeforeHook(callback, options = {}) { + this._addHook('before', callback, options); + } + + /** + * Add a function as a before each hook to the current test context + * @param {Function} callback - Function to add as before each hook to current test + * context + */ + addBeforeEachHook(callback, options = {}) { + this._addHook('beforeEach', callback, options); + } + + /** + * Add a function as a after each hook to the current test context + * @param {Function} callback - Function to add as after each hook to current test context + */ + addAfterEachHook(callback, options = {}) { + this._addHook('afterEach', callback, options); + } + + /** + * Add a function as a after hook to the current test context + * @param {Function} callback - Function to add as after hook to current test context + */ + addAfterHook(callback, options = {}) { + this._addHook('after', callback, options); + } + + /** + * Add a function to the list of hooks matching hookName, for the current test context + * @param {('before'|'beforeEach'|'afterEach'|'after')} hookName - The name of the hook to add the function to + * @param {Function} callback - Function to add as a hook + * @param {Object=} options - Hook configuration options + * @private + */ + _addHook(hookName, callback, options = {}) { + const hookAttribute = `${hookName}Hooks`; + + if (callback && typeof callback === 'function') { + this.currentTestContext[hookAttribute] = this.currentTestContext[hookAttribute] || []; + this.currentTestContext[hookAttribute].push({ + callback, + timeout: options.timeout || 5000, + }); + } else { + testDefinitionError(`non-function value ${callback} passed to ${hookName} for '${this.currentTestContext.name}'`); + } + } + + /** + * @typedef {Object} ContextOptions + * @property {Boolean} [focused=undefined] - whether context is focused or not. + * @property {Boolean} [pending=undefined] - whether context is pending or not. + */ + + /** + * @typedef {Object} TestOptions + * @extends ContextOptions + * @property {Number} [timeout=5000] - Number of milliseconds before test times out + */ + + /** + * Push a test context onto the context stack, making it the new current test context + * @param {String} name - The name of the new context + * @param {ContextOptions} options - Options for new context + */ + pushTestContext(name, options = {}) { + const testContextId = assignContextId(); + const parentContext = this.currentTestContext; + this.currentTestContext = this._initialiseContext(testContextId, Object.assign({ name, parentContextId: parentContext.id }, options)); + } + + /** + * Pop test context off the context stack, making the previous context the new + * current context. + */ + popTestContext() { + const parentContextId = this.currentTestContext.parentContextId; + this.currentTestContext = this.testContexts[parentContextId]; + } + + /** + * Add a test to the current test context + * @param {String} description - The new test's description + * @param {ContextOptions} options - The options for the new test + * @param {Function} testFunction - The function that comprises the test's body + */ + addTest(description, options, testFunction = undefined) { + let _testFunction; + let _options; + + if (testFunction) { + _testFunction = testFunction; + _options = options; + } else { + _testFunction = options; + _options = {}; + } + + if (_testFunction && typeof _testFunction === 'function') { + // Create test + const testId = assignTestId(); + + this._createTest(testId, { + testContextId: this.currentTestContext.id, + testSuiteId: this.testSuite.id, + description: this._testDescriptionContextPrefix(this.currentTestContext) + description, + func: _testFunction, + timeout: _options.timeout || 5000, + }); + + // Add tests to context + this.currentTestContext.testIds.push(testId); + + if (_options.focus || this.currentTestContext.focus) { + this.focusedTestIds[testId] = true; + } + + if (_options.pending || this.currentTestContext.pending) { + this.pendingTestIds[testId] = true; + } + } else { + testDefinitionError(`Invalid test function for "${description}".`); + } + } + + /** + * Get the prefix to prepend to a test to fully describe it. Any context that is + * nested 2 or more deep, i.e. non the root context nor a child of the root context, + * has its name recursively prepended to all tests in that context or contexts it + * contains. This allows tests to be easily displayed in a LinkedList during viewing + * and reporting the test suite. + * @param {Object} contextProperties - Properties of current context + * @param {Number} contextProperties.id - Id of context + * @param {String} contextProperties.name - Name of context + * @param {Number} contextProperties.parentContextId - Id of context's parent + * @param {String} [suffix=''] - Accumulation of context prefixes so far. Starts empty + * and collects context prefixes as it recursively calls itself to iterate up the + * context tree. + * @returns {String} Prefix to be prepended to current accumulative string of context + * names + * @private + */ + _testDescriptionContextPrefix({ id, name, parentContextId }, suffix = '') { + if (id === this.rootTestContextId || parentContextId === this.rootTestContextId) { + return suffix; + } + + return this._testDescriptionContextPrefix(this.testContexts[parentContextId], `${name} ${suffix}`); + } + + /** + * @typedef {Object} TestContext + * @property {Number} id - Globally unique id + * @property {String} name - Short description of context + * @property {Boolean} [focus=false] - Whether context is focused + * @property {Boolean} [pending=false] - Whether context is pending + * @property {Number} [parentContextId=undefined] - Id of context that contains the current one + * @property {Number[]} testIds - List of ids of tests to be run in current context + * @property {Number} testSuiteId - Id of test suite test context is apart of + */ + + /** + * Create a context from options provided + * @param {Number} testContextId - Id to assign to new context once it's created + * @param {Object} options - options to use to create the context + * @param {String} options.name - Name of context to create + * @param {Boolean} options.focus - Whether context is focused or not + * @param {Boolean} options.pending - Whether context is pending or not + * @param {Number} [options.parentContextId=undefined] - Id of context's parent + * @returns {TestContext} New test context once it has been initialised + * @private + */ + _initialiseContext(testContextId, { name, focus, pending, parentContextId }) { + const existingContext = this.testContexts[testContextId]; + + if (existingContext) { + return existingContext; + } + + const parentContext = this.testContexts[parentContextId]; + + const newTestContext = { + id: testContextId, + name, + focus: this._incorporateParentValue(parentContext, 'focus', focus, CONTEXT_OPERATORS.OR), + pending: this._incorporateParentValue(parentContext, 'pending', pending, CONTEXT_OPERATORS.OR), + parentContextId, + testIds: [], + testSuiteId: this.testSuite.id, + }; + + this.testContexts[testContextId] = newTestContext; + + return newTestContext; + } + + /** + * Recursively use an operator to consolidate a test's value with that of its test + * context chain. + * @param {TestContext} parentContext - Parent context to examine for its value + * @param {String} attributeName - name of the attribute to use from parent + * @param {*} value - Value of current context or test to use as one operand with + * the parent context's value + * @param {('OR')} operator - Operator to use to consolidate current value and + * parent context's value + * @returns {*} Consolidated value, encorporating context parents' values + * @private + */ + _incorporateParentValue(parentContext, attributeName, value, operator) { + if (!parentContext) { + return value; + } + + switch (operator) { + case CONTEXT_OPERATORS.OR: + return parentContext[attributeName] || value; + default: + throw new Error(`Unknown context operator ${operator}`); + } + } + + /** + * Create a new test from the options provided and add it to the suite + * @param {Number} testId - Unique id to give to the test + * @param {Object} testAttributes - attributes to create the test with + * @param {Number} testAttributes.testContextId - Id of context test belongs to + * @param {String} testAttributes.description - Short description of the test + * @param {Function} testAttributes.func - Function that comprises the body of the test + * @param {Number} testAttributes.testSuiteId - Id of test suite test belongs to + * @param {Number} testAttributes.timeout - Number of milliseconds before test times out + * @returns {Test} New test matching provided options + * @private + */ + _createTest(testId, { testContextId, description, func, testSuiteId, timeout }) { + const newTest = { + id: testId, + testContextId, + description, + func, + testSuiteId, + status: null, + message: null, + time: 0, + timeout, + }; + + this.tests[testId] = newTest; + + return newTest; + } + +} + +/** + * Log test definition error to the console with a message indicating the test + * definition was skipped. + * @param {String} error - Error message to include in message logged to the console + */ +function testDefinitionError(error) { + console.error(`ReactNativeFirebaseTests.TestDefinitionError: ${error}`); + console.error('This test was ignored.'); +} + +export default TestSuiteDefinition; diff --git a/tests/package.json b/tests/package.json new file mode 100644 index 00000000..9c38a381 --- /dev/null +++ b/tests/package.json @@ -0,0 +1,70 @@ +{ + "name": "react-native-firebase-tests", + "version": "0.0.1", + "private": true, + "scripts": { + "start": "node node_modules/react-native/local-cli/cli.js start", + "android:dev": "react-native run-android", + "android:prod": "react-native run-android --configuration=release", + "ios:dev": "react-native run-ios", + "ios:prod": "react-native run-ios --configuration=release", + "ios:pod:install": "cd ios && rm -rf ReactNativeFirebaseDemo.xcworkspace && pod install && cd ..", + "test": "echo 'Tests should be run from within the RN application.\n\rSee https://github.com/invertase/react-native-firebase-tests/blob/master/tests/README.md for more info.'", + "build-lib-for-tests": "babel --presets=es2015-mod,es3,react-native ./lib/ -d ./__tests__/build/lib/ --source-maps", + "internal-tests": "npm run build-lib-for-tests && babel --presets=es2015-mod,es3 ./__tests__/src/ -d ./__tests__/build/ --source-maps && node ./__tests__/build/index.js" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/invertase/react-native-firebase.git" + }, + "bugs": { + "url": "https://github.com/invertase/react-native-firebase/issues" + }, + "homepage": "https://github.com/invertase/react-native-firebase/tests/#readme", + "dependencies": { + "babel-preset-es2015-mod": "^6.6.0", + "babel-preset-es3": "^1.0.1", + "bluebird": "^3.5.0", + "bows": "^1.6.0", + "cuid": "^1.3.8", + "deeps": "^1.4.4", + "firebase": "^3.7.0", + "js-beautify": "^1.6.11", + "lodash.groupby": "^4.6.0", + "lodash.some": "^4.6.0", + "react": "~15.4.1", + "react-native": "0.40.0", + "react-native-firebase": "file:..", + "react-native-simple-toast": "0.0.5", + "react-native-vector-icons": "^4.0.0", + "react-navigation": "^1.0.0-beta.7", + "react-redux": "^5.0.3", + "redux": "^3.6.0", + "redux-logger": "^2.8.2", + "redux-persist": "^4.4.2", + "redux-thunk": "^2.2.0", + "should": "^11.2.0", + "should-sinon": "^0.0.5", + "sinon": "https://github.com/greena13/sinon.git" + }, + "devDependencies": { + "babel-cli": "^6.24.0", + "babel-eslint": "^7.1.1", + "babel-jest": "19.0.0", + "babel-plugin-flow-react-proptypes": "^0.21.0", + "babel-preset-react-native": "1.9.1", + "colors": "^1.1.2", + "eslint": "^3.16.1", + "eslint-config-airbnb": "^14.1.0", + "eslint-plugin-flowtype": "^2.30.0", + "eslint-plugin-import": "^2.2.0", + "eslint-plugin-jsx-a11y": "^4.0.0", + "eslint-plugin-react": "^6.10.0", + "jest": "19.0.2", + "react-test-renderer": "~15.4.1", + "redux-immutable-state-invariant": "^1.2.4" + }, + "jest": { + "preset": "react-native" + } +} diff --git a/tests/src/actions/AppActions.js b/tests/src/actions/AppActions.js new file mode 100644 index 00000000..1494c85e --- /dev/null +++ b/tests/src/actions/AppActions.js @@ -0,0 +1,17 @@ +export const APP_SET_NETWORK_STATE: string = 'APP_SET_NETWORK_STATE'; +export const APP_SET_APP_STATE: string = 'APP_SET_APP_STATE'; + +export function setNetworkState(isConnected: boolean): Object { + return { + type: APP_SET_NETWORK_STATE, + isConnected, + }; +} + +export function setAppState(appState: 'active' | 'background' | 'inactive'): Object { + return { + type: APP_SET_APP_STATE, + appState, + }; +} + diff --git a/tests/src/actions/FCMActions.js b/tests/src/actions/FCMActions.js new file mode 100644 index 00000000..619f2b11 --- /dev/null +++ b/tests/src/actions/FCMActions.js @@ -0,0 +1,8 @@ +export const FCM_SET_TOKEN: string = 'FCM_SET_TOKEN'; + +export function setToken(token: string): Object { + return { + type: FCM_SET_TOKEN, + token, + }; +} diff --git a/tests/src/actions/TestActions.js b/tests/src/actions/TestActions.js new file mode 100644 index 00000000..a2ed5fe3 --- /dev/null +++ b/tests/src/actions/TestActions.js @@ -0,0 +1,26 @@ +export const TEST_SET_SUITE_STATUS: string = 'TEST_SET_SUITE_STATUS'; +export const TEST_SET_STATUS: string = 'TEST_SET_STATUS'; + +export function setSuiteStatus({ suiteId, status, time, message, progress }) { + return { + type: TEST_SET_SUITE_STATUS, + suiteId, + + status, + message, + + time, + progress, + }; +} + +export function setTestStatus({ testId, status, time = 0, message = null }) { + return { + type: TEST_SET_STATUS, + testId, + + status, + message, + time, + }; +} diff --git a/tests/src/components/Banner.js b/tests/src/components/Banner.js new file mode 100644 index 00000000..18861ece --- /dev/null +++ b/tests/src/components/Banner.js @@ -0,0 +1,51 @@ +import React from 'react'; +import { StyleSheet, View, Text } from 'react-native'; + +function Banner({ type, children, style, textStyle }) { + return ( + + + {children} + + + ); +} + +Banner.propTypes = { + type: React.PropTypes.oneOf([ + 'success', + 'warning', + 'error', + 'info', + ]), + children: React.PropTypes.oneOfType([ + React.PropTypes.string, + React.PropTypes.array, + ]).isRequired, + style: View.propTypes.style, + textStyle: Text.propTypes.style, +}; + +const styles = StyleSheet.create({ + banner: { + alignItems: 'center', + elevation: 3, + }, + bannerText: { + color: '#ffffff', + }, + warning: { + backgroundColor: '#FFC107', + }, + error: { + backgroundColor: '#f44336', + }, + success: { + backgroundColor: '#4CAF50', + }, +}); + +export default Banner; diff --git a/tests/src/components/Icon.js b/tests/src/components/Icon.js new file mode 100644 index 00000000..8a2ace43 --- /dev/null +++ b/tests/src/components/Icon.js @@ -0,0 +1,75 @@ +import React from 'react'; +import { View, TouchableHighlight } from 'react-native'; +import VectorIcon from 'react-native-vector-icons/MaterialIcons'; + +type Props = { + name: string, + size?: number, + color?: string, + allowFontScaling?: boolean, + style?: Object, + rotate?: number, + onPress?: () => void, + underlayColor?: string, +}; + +// TODO Spin? +class Icon extends React.Component { + + constructor() { + super(); + this.measured = false; + this.state = { + width: 0, + }; + } + + setDimensions(e) { + if (!this.measured) { + this.measured = true; + this.setState({ + width: e.nativeEvent.layout.width, + }); + } + } + + props: Props; + + render() { + const { name, size = 24, color = '#757575', allowFontScaling = true, style, rotate, onPress, underlayColor } = this.props; + + const icon = ( + this.setDimensions(e)} + style={[ + style, + rotate ? { transform: [{ rotate: `${rotate}deg` }] } : null, + ]} + > + + + ); + + if (!onPress) { + return icon; + } + + return ( + + {icon} + + ); + } + +} + +export default Icon; diff --git a/tests/src/components/OverviewControlButton.js b/tests/src/components/OverviewControlButton.js new file mode 100644 index 00000000..4fe778bd --- /dev/null +++ b/tests/src/components/OverviewControlButton.js @@ -0,0 +1,70 @@ +import React, { PropTypes, Component } from 'react'; +import some from 'lodash.some'; +import { connect } from 'react-redux'; + +import Toast from 'react-native-simple-toast'; + +import { runTests } from '../tests/index'; +import RunStatus from '../../lib/RunStatus'; + +import Icon from '../components/Icon'; + +class OverviewControlButton extends Component { + constructor(props, context) { + super(props, context); + + this.handleOnPress = this.handleOnPress.bind(this); + } + + testSuitesAreRunning() { + const { testSuites } = this.props; + + return some(Object.values(testSuites), ({ status }) => status === RunStatus.RUNNING); + } + + handleOnPress() { + const { focusedTestIds, pendingTestIds, tests } = this.props; + runTests(tests, { focusedTestIds, pendingTestIds }); + Toast.show('Running all suite tests.'); + } + + render() { + if (this.testSuitesAreRunning()) { + return ( + + ); + } + + return ( + + ); + } +} + +OverviewControlButton.propTypes = { + tests: PropTypes.objectOf(PropTypes.object).isRequired, + testSuites: PropTypes.objectOf(PropTypes.object).isRequired, + focusedTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, + pendingTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, +}; + + +function mapStateToProps({ tests, testSuites, focusedTestIds, pendingTestIds }) { + return { + tests, + testSuites, + focusedTestIds, + pendingTestIds, + }; +} + +export default connect(mapStateToProps)(OverviewControlButton); diff --git a/tests/src/components/StatusIndicator.js b/tests/src/components/StatusIndicator.js new file mode 100644 index 00000000..b6180d65 --- /dev/null +++ b/tests/src/components/StatusIndicator.js @@ -0,0 +1,52 @@ +import { View, Text } from 'react-native'; +import React, { PropTypes, Component } from 'react'; + +import RunStatus from '../../lib/RunStatus'; +import Icon from './Icon'; + +class StatusIndicator extends Component { + + render() { + const { status, progress } = this.props; + + switch (status) { + case RunStatus.RUNNING: + if (progress > 0) { + return ( + + + {progress.toFixed(0)}% + + + ); + } + + return ( + + ); + case RunStatus.OK: + return ( + + ); + case RunStatus.ERR: + return ( + + ); + default: + return null; + } + } + +} + +StatusIndicator.propTypes = { + status: PropTypes.oneOf(Object.values(RunStatus)), + progress: PropTypes.number, +}; + +StatusIndicator.defaultProps = { + status: null, + progress: 0 +}; + +module.exports = StatusIndicator; diff --git a/tests/src/components/TestControlButton.js b/tests/src/components/TestControlButton.js new file mode 100644 index 00000000..c11cf98f --- /dev/null +++ b/tests/src/components/TestControlButton.js @@ -0,0 +1,71 @@ +import React, { PropTypes, Component } from 'react'; +import { connect } from 'react-redux'; +import Toast from 'react-native-simple-toast'; + +import RunStatus from '../../lib/RunStatus'; +import { runTest } from '../tests/index'; + +import Icon from './Icon'; + +class TestControlButton extends Component { + constructor(props, context) { + super(props, context); + + this.handleOnPress = this.handleOnPress.bind(this); + } + + testIsPending() { + const { test: { id }, pendingTestIds } = this.props; + return !!pendingTestIds[id]; + } + + handleOnPress() { + const { test: { id, description } } = this.props; + + runTest(id); + Toast.show(`Running ${description}.`); + } + + render() { + const { test: { status } } = this.props; + + if (status !== RunStatus.STARTED && !this.testIsPending()) { + return ( + + ); + } + + return null; + } + +} + +TestControlButton.propTypes = { + test: PropTypes.shape({ + id: PropTypes.number.isRequired, + status: PropTypes.string, + description: PropTypes.string.isRequired, + }).isRequired, + + pendingTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, +}; + +TestControlButton.defaultProps = { + +}; + +function mapStateToProps({ tests, pendingTestIds }, { testId }) { + const test = tests[testId]; + + return { + test, + pendingTestIds, + }; +} + +module.exports = connect(mapStateToProps)(TestControlButton); diff --git a/tests/src/components/TestSuiteControlButton.js b/tests/src/components/TestSuiteControlButton.js new file mode 100644 index 00000000..ca8a0cd3 --- /dev/null +++ b/tests/src/components/TestSuiteControlButton.js @@ -0,0 +1,96 @@ +import React, { PropTypes, Component } from 'react'; +import { connect } from 'react-redux'; + +import Toast from 'react-native-simple-toast'; + +import RunStatus from '../../lib/RunStatus'; +import { runTests } from '../tests/index'; + +import Icon from './Icon'; + +class TestSuiteControlButton extends Component { + constructor(props, context) { + super(props, context); + + this.toggleOnlyShowFailingTests = this.toggleOnlyShowFailingTests.bind(this); + this.startTestSuite = this.startTestSuite.bind(this); + } + + startTestSuite() { + const { testSuite: { name, testIds }, tests, focusedTestIds, pendingTestIds } = this.props; + + const testSuiteTests = testIds.reduce((memo, testId) => { + // eslint-disable-next-line no-param-reassign + memo[testId] = tests[testId]; + return memo; + }, {}); + + runTests(testSuiteTests, { focusedTestIds, pendingTestIds }); + + Toast.show(`Running ${name} tests.`); + } + + toggleOnlyShowFailingTests() { + const { onlyShowFailingTests, onFilterChange } = this.props; + onFilterChange({ onlyShowFailingTests: !onlyShowFailingTests }); + } + + render() { + const { testSuite: { status }, onlyShowFailingTests } = this.props; + + if (status === RunStatus.ERR) { + return ( + + ); + } else if (status !== RunStatus.RUNNING) { + return ( + + ); + } + + return null; + } + +} + +TestSuiteControlButton.propTypes = { + testSuite: PropTypes.shape({ + status: PropTypes.oneOf(Object.values(RunStatus)), + }).isRequired, + + tests: PropTypes.objectOf(PropTypes.object).isRequired, + focusedTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, + pendingTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, + + onlyShowFailingTests: PropTypes.bool, + + onFilterChange: PropTypes.func.isRequired, +}; + +TestSuiteControlButton.defaultProps = { + onlyShowFailingTests: false, +}; + + +function mapStateToProps({ tests, testSuites, focusedTestIds, pendingTestIds }, { testSuiteId }) { + const testSuite = testSuites[testSuiteId]; + + return { + tests, + testSuite, + focusedTestIds, + pendingTestIds, + }; +} + +module.exports = connect(mapStateToProps)(TestSuiteControlButton); diff --git a/tests/src/containers/CoreContainer.js b/tests/src/containers/CoreContainer.js new file mode 100644 index 00000000..2111b9dc --- /dev/null +++ b/tests/src/containers/CoreContainer.js @@ -0,0 +1,82 @@ +// @flow +import React from 'react'; +import { View, Text, AppState, NetInfo, StatusBar, Platform } from 'react-native'; +import { connect } from 'react-redux'; + +import Navigator from '../navigator'; +import { setNetworkState, setAppState } from '../actions/AppActions'; + +type Props = { + dispatch: () => void, +}; + +class CoreContainer extends React.Component { + + constructor() { + super(); + this._isConnected = false; + } + + /** + * On app mount, listen for changes to app & network state + */ + componentDidMount() { + if (Platform.OS === 'android') { + StatusBar.setBackgroundColor('#0279ba'); + } + if (Platform.OS === 'ios') { + StatusBar.setBarStyle('light-content') + } + AppState.addEventListener('change', this.handleAppStateChange); + NetInfo.isConnected.fetch().then((isConnected) => { + this.handleAppStateChange('active'); // Force connect (react debugger issue) + this.props.dispatch(setNetworkState(isConnected)); + NetInfo.isConnected.addEventListener('change', this.handleNetworkChange); + }); + } + + /** + * Remove listeners on app unmount + */ + componentWillUnmount() { + AppState.removeEventListener('change', this.handleAppStateChange); + NetInfo.isConnected.removeEventListener('change', this.handleNetworkChange); + } + + props: Props; + + /** + * Handle app state changes + * https://facebook.github.io/react-native/docs/appstate.html + * @param state + */ + handleAppStateChange = (state) => { + this.props.dispatch(setAppState(state)); + if (state === 'active' && this._isConnected) { + // firestack.database().goOnline(); + } else if (state === 'background') { + // firestack.database().goOffline(); + } + }; + + /** + * Handle app network changes + * https://facebook.github.io/react-native/docs/netinfo.html + * @param isConnected + */ + handleNetworkChange = (isConnected) => { + this._isConnected = isConnected; + this.props.dispatch(setNetworkState(isConnected)); + if (isConnected) { + // firestack.database().goOnline(); + } else { + // firestack.database().goOffline(); + } + }; + + render() { + return ; + } +} + +export default connect()(CoreContainer); diff --git a/tests/src/firebase.js b/tests/src/firebase.js new file mode 100644 index 00000000..e51a2b06 --- /dev/null +++ b/tests/src/firebase.js @@ -0,0 +1,32 @@ +import firebase from 'firebase'; +import RNfirebase from 'react-native-firebase'; + +import DatabaseContents from './tests/support/DatabaseContents'; + +const config = { + apiKey: 'AIzaSyDnVqNhxU0Biit9nCo4RorAh5ulQQwko3E', + authDomain: 'rnfirebase-b9ad4.firebaseapp.com', + databaseURL: 'https://rnfirebase-b9ad4.firebaseio.com', + storageBucket: 'rnfirebase-b9ad4.appspot.com', + messagingSenderId: '305229645282', +}; + +const instances = { + web: firebase.initializeApp(config), + native: RNfirebase.initializeApp({ + debug: __DEV__ ? '*' : false, + errorOnMissingPlayServices: false, + persistence: true, + }), +}; + +instances.web.database().ref('tests/types').set(DatabaseContents.DEFAULT); + +instances.web.database().ref('tests/priority').setWithPriority({ + foo: 'bar', +}, 666); + + +// instances.native.messaging().subscribeToTopic('fcm_test'); + +export default instances; diff --git a/tests/src/helpers.js b/tests/src/helpers.js new file mode 100644 index 00000000..2227bfea --- /dev/null +++ b/tests/src/helpers.js @@ -0,0 +1,3 @@ +// import fs from 'fs'; +import path from 'path'; + diff --git a/tests/src/main.js b/tests/src/main.js new file mode 100644 index 00000000..35086ae6 --- /dev/null +++ b/tests/src/main.js @@ -0,0 +1,64 @@ +import React, { Component } from 'react'; +import { Provider } from 'react-redux'; + +import CoreContainer from './containers/CoreContainer'; +import setupStore from './store/setup'; +import { setupSuites } from './tests/index'; + +global.Promise = require('bluebird'); + +type State = { + loading: boolean, + store: any, +}; + +function bootstrap() { + // Remove logging on production + if (!__DEV__) { + console.log = () => { + }; + console.warn = () => { + }; + console.error = () => { + }; + console.disableYellowBox = true; + } + + class Root extends Component { + constructor() { + super(); + this.state = { + loading: true, + store: null, + }; + } + + state: State; + + componentDidMount() { + setupStore((store) => { + setupSuites(store); + this.setState({ + store, + loading: false, + }); + }); + } + + render() { + if (this.state.loading) { + return null; + } + + return ( + + + + ); + } + } + + return Root; +} + +export default bootstrap(); diff --git a/tests/src/navigator.js b/tests/src/navigator.js new file mode 100644 index 00000000..d54f30d4 --- /dev/null +++ b/tests/src/navigator.js @@ -0,0 +1,20 @@ +import { StackNavigator } from 'react-navigation'; + +import Overview from './screens/Overview'; +import Suite from './screens/Suite'; +import Test from './screens/Test'; + +export default StackNavigator({ + Overview: { screen: Overview }, + Suite: { screen: Suite }, + Test: { screen: Test }, +}); + +export const initialNavState = { + index: 0, + routes: [ + { + key: 'Overview', + }, + ], +}; diff --git a/tests/src/reducers/device.js b/tests/src/reducers/device.js new file mode 100644 index 00000000..7646352d --- /dev/null +++ b/tests/src/reducers/device.js @@ -0,0 +1,35 @@ +import * as fcmTypes from '../actions/FCMActions'; +import * as appTypes from '../actions/AppActions'; + +type State = { + appState: 'string', + isConnected: boolean, + fcmToken: string, +}; + +const initialState = { + appState: 'active', + isConnected: true, + fcmToken: '', +}; + +function device(state: State = initialState, action: Object): State { + + if (action.type === appTypes.APP_SET_NETWORK_STATE) { + return { + ...state, + isConnected: action.isConnected, + }; + } + + if (action.type === appTypes.APP_SET_APP_STATE) { + return { + ...state, + appState: action.appState, + }; + } + + return state; +} + +export default device; diff --git a/tests/src/reducers/focusedTestIdsReducers.js b/tests/src/reducers/focusedTestIdsReducers.js new file mode 100644 index 00000000..c413d889 --- /dev/null +++ b/tests/src/reducers/focusedTestIdsReducers.js @@ -0,0 +1,9 @@ +import { initialState } from '../tests/index'; + +const initState = initialState(); + +function focusedTestIdsReducers(state = initState.focusedTestIds): State { + return state; +} + +export default focusedTestIdsReducers; diff --git a/tests/src/reducers/index.js b/tests/src/reducers/index.js new file mode 100644 index 00000000..17fcc7d7 --- /dev/null +++ b/tests/src/reducers/index.js @@ -0,0 +1,17 @@ +import { combineReducers } from 'redux'; + +import device from './device'; +import tests from './testsReducers'; +import testContexts from './testContextsReducers'; +import testSuites from './testSuitesReducers'; +import pendingTestIds from './pendingTestIdsReducers'; +import focusedTestIds from './focusedTestIdsReducers'; + +export default combineReducers({ + device, + pendingTestIds, + focusedTestIds, + testContexts, + tests, + testSuites, +}); diff --git a/tests/src/reducers/pendingTestIdsReducers.js b/tests/src/reducers/pendingTestIdsReducers.js new file mode 100644 index 00000000..89cebeda --- /dev/null +++ b/tests/src/reducers/pendingTestIdsReducers.js @@ -0,0 +1,9 @@ +import { initialState } from '../tests'; + +const initState = initialState(); + +function pendingTestIdsReducers(state = initState.pendingTestIds): State { + return state; +} + +export default pendingTestIdsReducers; diff --git a/tests/src/reducers/testContextsReducers.js b/tests/src/reducers/testContextsReducers.js new file mode 100644 index 00000000..201dd4d2 --- /dev/null +++ b/tests/src/reducers/testContextsReducers.js @@ -0,0 +1,9 @@ +import { initialState } from '../tests/index'; + +const initState = initialState(); + +function testsReducers(state = initState.testContexts): State { + return state; +} + +export default testsReducers; diff --git a/tests/src/reducers/testSuitesReducers.js b/tests/src/reducers/testSuitesReducers.js new file mode 100644 index 00000000..becf6514 --- /dev/null +++ b/tests/src/reducers/testSuitesReducers.js @@ -0,0 +1,23 @@ +import * as testActions from '../actions/TestActions'; +import { flatten, unflatten } from 'deeps'; +import { initialState } from '../tests/index'; + +const initState = initialState(); + +function testsReducers(state = initState.testSuites, action: Object): State { + + if (action.type === testActions.TEST_SET_SUITE_STATUS) { + const flattened = flatten(state); + + if (action.status) flattened[`${action.suiteId}.status`] = action.status; + if (action.message) flattened[`${action.suiteId}.message`] = action.message; + if (action.progress) flattened[`${action.suiteId}.progress`] = action.progress; + if (!isNaN(action.time)) flattened[`${action.suiteId}.time`] = action.time; + + return unflatten(flattened); + } + + return state; +} + +export default testsReducers; diff --git a/tests/src/reducers/testsReducers.js b/tests/src/reducers/testsReducers.js new file mode 100644 index 00000000..204e600f --- /dev/null +++ b/tests/src/reducers/testsReducers.js @@ -0,0 +1,22 @@ +import * as testActions from '../actions/TestActions'; +import { flatten, unflatten } from 'deeps'; +import { initialState } from '../tests/index'; + +const initState = initialState(); + +function testsReducers(state = initState.tests, action: Object): State { + + if (action.type === testActions.TEST_SET_STATUS) { + const flattened = flatten(state); + + flattened[`${action.testId}.status`] = action.status; + flattened[`${action.testId}.message`] = action.message; + flattened[`${action.testId}.time`] = action.time; + + return unflatten(flattened); + } + + return state; +} + +export default testsReducers; diff --git a/tests/src/screens/Overview.js b/tests/src/screens/Overview.js new file mode 100644 index 00000000..e52b2a94 --- /dev/null +++ b/tests/src/screens/Overview.js @@ -0,0 +1,299 @@ +import React, { PropTypes } from 'react'; +import { StyleSheet, View, Text, ListView, TouchableHighlight } from 'react-native'; +import { connect } from 'react-redux'; +import some from 'lodash.some'; + +import RunStatus from '../../lib/RunStatus'; + +import Banner from '../components/Banner'; +import StatusIndicator from '../components/StatusIndicator'; +import OverviewControlButton from '../components/OverviewControlButton'; + +class Overview extends React.Component { + // noinspection JSUnusedGlobalSymbols + static navigationOptions = { + title: 'Test Suites', + header: () => { + return { + style: { backgroundColor: '#0288d1' }, + tintColor: '#ffffff', + right: ( + + + + ), + }; + }, + }; + + /** + * Renders separator between ListView sections + * @param {String} sectionID + * @param {String} rowID + * @returns {XML} JSX component used as ListView separator + */ + static renderSeparator(sectionID, rowID) { + return ( + + ); + } + + /** + * Filters test suites to those that have one or more tests that should be visible. + * If one or more tests are focused it only returns test suites with focused tests, + * otherwise, it returns all test suites. + * @param {IndexedTestSuiteGroup} testSuites - group of available test suites + * @param {IdLookup} focusedTestIds - lookup for focused tests + * @returns {IndexedTestSuiteGroup} - indexed group of test suites that should be shown + */ + static testSuitesToShow({ testSuites, focusedTestIds }) { + if (Object.keys(focusedTestIds).length > 0) { + return Object.keys(testSuites).reduce((memo, testSuiteId) => { + const testSuite = testSuites[testSuiteId]; + + const testSuiteHasFocusedTests = some(testSuite.testIds, (testId) => { + return focusedTestIds[testId]; + }); + + if (testSuiteHasFocusedTests) { + // eslint-disable-next-line no-param-reassign + memo[testSuiteId] = testSuite; + } + + return memo; + }, {}); + } + + return testSuites; + } + + /** + * Copies initial values for test suites from props into state, so they may be + * rendered as a ListView + * @param {Object} props - props used to render component + * @param {Object} context - context used to render component + */ + constructor(props, context) { + super(props, context); + + this.dataSource = new ListView.DataSource({ + rowHasChanged: (r1, r2) => JSON.stringify(r1) !== JSON.stringify(r2), + }); + + this.state = { + dataBlob: this.dataSource.cloneWithRows(Overview.testSuitesToShow(props)), + }; + } + + + /** + * Copies latest test suite status into state so they may be rendered as a ListView + * @param {Object} nextProps - next props used to render component + * @param {Object.} nextProps.testSuites - test suites to render + * @param {IdLookup} nextProps.focusedTestIds - lookup for focus tests + */ + componentWillReceiveProps({ testSuites, focusedTestIds }) { + this.setState({ + dataBlob: this.dataSource.cloneWithRows(Overview.testSuitesToShow({ testSuites, focusedTestIds })), + }); + } + + /** + * Navigate to test suite screen + * @param {TestSuiteId} testSuiteId - id of test suite to navigate to + */ + goToTestSuite(testSuite) { + const { navigation: { navigate } } = this.props; + + navigate('Suite', { testSuiteId: testSuite.id, title: testSuite.name }); + } + + /** + * + * @param testSuite + * @param sectionId + * @param rowId + * @param highlight + * @returns {XML} + */ + renderRow(testSuite, sectionId, rowId, highlight) { + const { description, name, status, progress } = testSuite; + + return ( + { + this.goToTestSuite(testSuite); + highlight(); + }} + > + + + {name} + + {description} + + + + + + + + ); + } + + /** + * Renders a warning toast banner if there are one or more tests that are pending + * @returns {null|XML} Toast banner if there are test pending, else null + */ + renderPendingTestsBanner() { + const { pendingTestIds } = this.props; + + const pendingTestsCount = Object.keys(pendingTestIds).length; + + if (pendingTestsCount > 0) { + return ( + + {pendingTestsCount} pending test(s). + + ); + } + + return null; + } + + renderStatusBanner() { + const { testSuites } = this.props; + + let totalProgress = 0; + let isRunning = false; + let isErrors = false; + let totalTime = 0; + + Object.values(testSuites).forEach(({ progress, status, time }) => { + totalProgress += progress; + totalTime += time; + + if (status === RunStatus.RUNNING) { + isRunning = true; + } else if (status === RunStatus.ERR) { + isErrors = true; + } + }); + + totalProgress /= Object.keys(testSuites).length; + + if (isRunning) { + return ( + Running ({(totalTime / 1000).toFixed(0)}s) {totalProgress.toFixed(2)}% + ); + } else if (totalProgress > 0) { + if (isErrors) { + return ( + Tests Complete with errors + ); + } + + return ( + Tests Complete + ); + } + + return null; + } + + + /** + * Renders ListView of test suites that should be visible, taking into consideration + * any focused tests + * @returns {XML} ListView of test suites + */ + render() { + return ( + + { this.renderPendingTestsBanner() } + { this.renderStatusBanner() } + this.renderRow(...args)} + renderSeparator={(...args) => Overview.renderSeparator(...args)} + /> + + ); + } +} + +Overview.propTypes = { + testSuites: PropTypes.objectOf(PropTypes.shape({ + id: PropTypes.number.isRequired, + description: PropTypes.string.isRequired, + name: PropTypes.string.isRequired, + status: PropTypes.oneOf(Object.values(RunStatus)), + })).isRequired, + + tests: PropTypes.objectOf(PropTypes.shape({ + testSuiteId: PropTypes.number.isRequired, + })).isRequired, + + navigation: PropTypes.shape({ + navigate: PropTypes.func.isRequired, + }).isRequired, + + running: PropTypes.bool.isRequired, + + pendingTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, + focusedTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, +}; +const styles = StyleSheet.create({ + rightContainer: { + marginRight: 16, + }, + container: { + flex: 1, + backgroundColor: '#ffffff', + }, + title: { + fontSize: 17, + fontWeight: '600', + }, + description: { + fontSize: 11, + }, + statusContainer: { + flex: 1, + alignItems: 'flex-end', + }, + row: { + height: 56, + paddingHorizontal: 16, + flexDirection: 'row', + alignItems: 'center', + }, + error: { + backgroundColor: 'rgba(255, 0, 0, 0.054)', + }, + separator: { + height: 1, + backgroundColor: '#eeeeee', + }, +}); + +function mapStateToProps({ testSuites, tests, pendingTestIds, focusedTestIds }) { + return { + testSuites, + tests, + pendingTestIds, + focusedTestIds, + running: Object.values(testSuites).filter(suite => suite.status === RunStatus.RUNNING).length > 0, + }; +} + +export default connect(mapStateToProps)(Overview); diff --git a/tests/src/screens/Suite.js b/tests/src/screens/Suite.js new file mode 100644 index 00000000..884727df --- /dev/null +++ b/tests/src/screens/Suite.js @@ -0,0 +1,404 @@ +import React, { PropTypes } from 'react'; +import { StyleSheet, View, Text, ListView, TouchableHighlight } from 'react-native'; +import { connect } from 'react-redux'; + +import RunStatus from '../../lib/RunStatus'; + +import Banner from '../components/Banner'; + +import StatusIndicator from '../components/StatusIndicator'; +import TestSuiteControlButton from '../components/TestSuiteControlButton'; + +class Suite extends React.Component { + + static navigationOptions = { + title: ({ state: { params: { title } } }) => { + return title; + }, + header: ({ state: { params: { testSuiteId, onlyShowFailingTests } }, setParams }) => { + return { + style: { backgroundColor: '#0288d1' }, + tintColor: '#ffffff', + right: ( + + + + ), + }; + }, + }; + + /** + * Render test group header + * @param data + * @param title + * @returns {XML} + */ + static renderHeader(data, title) { + return ( + + + {title.toUpperCase()} + + + ); + } + + constructor(props) { + super(props); + + this.dataSource = new ListView.DataSource({ + rowHasChanged: (r1, r2) => JSON.stringify(r1) !== JSON.stringify(r2), + sectionHeaderHasChanged: (s1, s2) => s1 !== s2, + }); + + this.state = { + dataBlob: this.dataSource.cloneWithRowsAndSections(buildRowsWithSections(props)), + }; + } + + /** + * componentWillReceiveProps + * @param nextProps + */ + componentWillReceiveProps(nextProps) { + const { + tests, + testContexts, + navigation: { state: { params: { onlyShowFailingTests } } }, + } = nextProps; + + const newRowsWithSections = (() => { + if (onlyShowFailingTests) { + return Object.values(testContexts).reduce((sections, context) => { + const { name } = context; + + context.testIds.forEach((testId) => { + const test = tests[testId]; + + if (test && test.status === RunStatus.ERR) { + // eslint-disable-next-line no-param-reassign + sections[name] = sections[name] || []; + sections[name].push(test); + } + }); + + return sections; + }, {}); + } + + return buildRowsWithSections(nextProps); + })(); + + this.setState({ + dataBlob: this.dataSource.cloneWithRowsAndSections(newRowsWithSections), + }); + } + + /** + * Go to a single test + * @param testId + */ + goToTest(test) { + const { navigation: { navigate } } = this.props; + + navigate('Test', { testId: test.id, title: test.description }); + } + + /** + * Render test row + * @param test + * @param sectionId + * @param rowId + * @param highlight + * @returns {XML} + */ + renderRow(test, sectionId, rowId, highlight) { + const { pendingTestIds } = this.props; + const { status, description, id } = test; + + return ( + { + this.goToTest(test); + highlight(); + }} + > + + + + {description} + + + + + + + + ); + } + + /** + * + * @param sectionID + * @param rowID + * @returns {XML} + */ + renderSeparator(sectionID, rowID) { + return ( + + ); + } + + renderPendingTestsBanner() { + const { testSuite: { testIds }, pendingTestIds } = this.props; + + let pendingTestsCount = 0; + + testIds.forEach((testId) => { + if (pendingTestIds[testId]) { + pendingTestsCount += 1; + } + }); + + if (pendingTestsCount) { + return ( + + {pendingTestsCount} pending test(s). + + ); + } + + return null; + } + + renderStatusBanner() { + const { testSuite: { status, progress, time, message } } = this.props; + + switch (status) { + case RunStatus.RUNNING: + + return ( + + Tests are currently running ({ progress.toFixed(2) }%). + + ); + + case RunStatus.OK: + + return ( + + Tests passed. ({ time }ms) + + ); + + case RunStatus.ERR: + + return ( + + {message} ({time}ms) + + ); + + default: + return null; + } + } + + /** + * + * @returns {XML} + */ + render() { + const { dataBlob } = this.state; + + return ( + + + { this.renderPendingTestsBanner() } + { this.renderStatusBanner() } + + Suite.renderHeader(...args)} + renderRow={(...args) => this.renderRow(...args)} + renderSeparator={(...args) => this.renderSeparator(...args)} + /> + + ); + } + +} + +Suite.propTypes = { + navigation: PropTypes.shape({ + setParams: PropTypes.func.isRequired, + navigate: PropTypes.func.isRequired, + state: PropTypes.shape({ + params: PropTypes.object, + onlyShowFailingTests: PropTypes.bool, + }).isRequired, + }).isRequired, + + testSuite: PropTypes.shape({ + status: PropTypes.string, + progress: PropTypes.number, + time: PropTypes.number, + message: PropTypes.string, + }).isRequired, + + testContexts: PropTypes.objectOf(PropTypes.shape({ + name: PropTypes.string.isRequired, + testIds: PropTypes.arrayOf(PropTypes.number).isRequired, + })).isRequired, + + tests: PropTypes.objectOf(PropTypes.shape({ + id: PropTypes.number, + description: PropTypes.string, + status: PropTypes.oneOf(Object.values(RunStatus)), + })).isRequired, + + pendingTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, + focusedTestIds: PropTypes.objectOf(PropTypes.bool).isRequired, +}; + +const styles = StyleSheet.create({ + container: { + flex: 1, + backgroundColor: '#ffffff', + }, + banner: { + alignItems: 'center', + elevation: 3, + }, + bannerText: { + color: '#ffffff', + }, + inProgress: { + backgroundColor: '#FFC107', + }, + errorBanner: { + backgroundColor: '#f44336', + }, + header: { + elevation: 3, + justifyContent: 'center', + height: 25, + paddingHorizontal: 16, + backgroundColor: '#ECEFF1', + }, + headerText: { + fontWeight: '800', + }, + row: { + paddingHorizontal: 16, + height: 48, + flexDirection: 'row', + }, + rowContent: { + justifyContent: 'center', + }, + disabledRow: { + color: '#c3c3c3', + }, + error: { + backgroundColor: 'rgba(255, 0, 0, 0.054)', + }, + separator: { + height: 1, + backgroundColor: '#eeeeee', + }, +}); + +function buildRowsWithSections({ testContexts, tests, focusedTestIds }) { + const someTestsAreFocused = Object.keys(focusedTestIds).length > 0; + + return Object.values(testContexts).reduce((sections, testContext) => { + const { testIds } = testContext; + + const contextTestsToShow = testIds.reduce((memo, testId) => { + const test = tests[testId]; + + if (someTestsAreFocused) { + if (focusedTestIds[testId]) { + memo.push(test); + } + } else { + memo.push(test); + } + + return memo; + }, []); + + if (contextTestsToShow.length > 0) { + const effectiveContext = highestNonRootAncestor(testContext, testContexts); + // eslint-disable-next-line no-param-reassign + sections[effectiveContext.name] = sections[effectiveContext.name] || []; + // eslint-disable-next-line no-param-reassign + sections[effectiveContext.name] = sections[effectiveContext.name].concat(contextTestsToShow); + } + + return sections; + }, {}); +} + +function highestNonRootAncestor(testContext, testContexts) { + const parentContextId = testContext.parentContextId; + + if (parentContextId) { + const parentContext = testContexts[parentContextId]; + const parentContextIsNotRoot = parentContext && parentContext.parentContextId; + + if (parentContextIsNotRoot) { + return highestNonRootAncestor(parentContext, testContexts); + } + } + + return testContext; +} + +function mapStateToProps(state, { navigation: { state: { params: { testSuiteId } } } }) { + const { tests, testContexts, testSuites, pendingTestIds, focusedTestIds } = state; + const testSuite = testSuites[testSuiteId]; + + const testSuiteContexts = testSuite.testContextIds.reduce((suiteContexts, contextId) => { + // eslint-disable-next-line no-param-reassign + suiteContexts[contextId] = testContexts[contextId]; + + return suiteContexts; + }, {}); + + const testSuiteTests = testSuite.testIds.reduce((suiteTests, testId) => { + // eslint-disable-next-line no-param-reassign + suiteTests[testId] = tests[testId]; + + return suiteTests; + }, {}); + + return { + testSuite, + testContexts: testSuiteContexts, + tests: testSuiteTests, + pendingTestIds, + focusedTestIds, + }; +} + +export default connect(mapStateToProps)(Suite); diff --git a/tests/src/screens/Test.js b/tests/src/screens/Test.js new file mode 100644 index 00000000..a8e0e233 --- /dev/null +++ b/tests/src/screens/Test.js @@ -0,0 +1,149 @@ +import React, { PropTypes } from 'react'; +import { StyleSheet, View, Text, ScrollView } from 'react-native'; +import { connect } from 'react-redux'; +import { js_beautify as beautify } from 'js-beautify'; + +import Banner from '../components/Banner'; +import RunStatus from '../../lib/RunStatus'; +import TestControlButton from '../components/TestControlButton'; + +class Test extends React.Component { + + static navigationOptions = { + title: ({ state: { params: { title } } }) => { + return title; + }, + header: ({ state: { params: { testId } } }) => { + return { + style: { backgroundColor: '#0288d1' }, + tintColor: '#ffffff', + right: ( + + + + ), + }; + }, + }; + + static renderBanner({ status, time }) { + switch (status) { + case RunStatus.RUNNING: + return ( + + Test is currently running. + + ); + case RunStatus.OK: + return ( + + Test passed. ({time}ms) + + ); + case RunStatus.ERR: + return ( + + Test failed. ({time}ms) + + ); + default: + return null; + } + } + + componentDidMount() { + const { navigation: { setParams }, test } = this.props; + + setParams({ test }); + } + + renderError() { + const { test: { message } } = this.props; + + if (message) { + return ( + + Test Error + + {message} + + + ); + } + + return null; + } + + + render() { + const { test: { func, status, time } } = this.props; + + return ( + + {Test.renderBanner({ status, time })} + + {this.renderError()} + Test Code Preview + + + {beautify(removeLastLine(removeFirstLine(func.toString())), { indent_size: 4, break_chained_methods: true })} + + + + + ); + } +} + +Test.propTypes = { + test: PropTypes.shape({ + status: PropTypes.string, + time: PropTypes.number, + message: PropTypes.string, + func: PropTypes.function, + }).isRequired, + + navigation: PropTypes.shape({ + setParams: PropTypes.func.isRequired, + }).isRequired, +}; + +const styles = StyleSheet.create({ + container: { + flex: 1, + backgroundColor: '#ffffff', + }, + content: {}, + code: { + backgroundColor: '#3F373A', + color: '#c3c3c3', + padding: 5, + fontSize: 12, + }, + codeHeader: { + fontWeight: '600', + fontSize: 18, + backgroundColor: '#000', + color: '#fff', + padding: 5, + }, +}); + +function select({ tests }, { navigation: { state: { params: { testId } } } }) { + const test = tests[testId]; + + return { + test, + }; +} + +function removeLastLine(multiLineString) { + const index = multiLineString.lastIndexOf('\n'); + return multiLineString.substring(0, index); +} + +function removeFirstLine(multiLineString) { + return multiLineString.substring(multiLineString.indexOf('\n') + 1); +} + +export default connect(select)(Test); diff --git a/tests/src/store/setup.js b/tests/src/store/setup.js new file mode 100644 index 00000000..06cc0107 --- /dev/null +++ b/tests/src/store/setup.js @@ -0,0 +1,43 @@ +import { AsyncStorage } from 'react-native'; +import { applyMiddleware, createStore, compose } from 'redux'; +import thunk from 'redux-thunk'; +import reduxLogger from 'redux-logger'; +import { persistStore, autoRehydrate } from 'redux-persist'; + +import whitelist from './whitelist'; +import reducers from '../reducers'; + +function setup(done) { + const isDev = global.isDebuggingInChrome || __DEV__; + + const logger = reduxLogger({ + predicate: () => isDev, + collapsed: true, + duration: true, + }); + + // AsyncStorage.clear(); + + // Setup redux middleware + const middlewares = [autoRehydrate()]; + + middlewares.push(applyMiddleware(...[thunk])); + + if (isDev) { + middlewares.push(applyMiddleware(...[logger])); + middlewares.push(applyMiddleware(require('redux-immutable-state-invariant')())); + } + + const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose; + + const store = createStore(reducers, {}, composeEnhancers(...middlewares)); + + // Attach the store to the Chrome debug window + if (global.isDebuggingInChrome) { + window.store = store; + } + + persistStore(store, { whitelist, storage: AsyncStorage }, () => done(store)); +} + +export default setup; diff --git a/tests/src/store/whitelist.js b/tests/src/store/whitelist.js new file mode 100644 index 00000000..1c4f017e --- /dev/null +++ b/tests/src/store/whitelist.js @@ -0,0 +1 @@ +export default ['']; diff --git a/tests/src/tests/analytics/analytics.js b/tests/src/tests/analytics/analytics.js new file mode 100644 index 00000000..105c585c --- /dev/null +++ b/tests/src/tests/analytics/analytics.js @@ -0,0 +1,64 @@ + +export default function addTests({ describe, it, firebase }) { + describe('Analytics', () => { + it('logEvent: it should log a text event without error', () => { + return new Promise((resolve) => { + firebase.native.analytics().logEvent('test_event'); + resolve(); + }); + }); + + it('logEvent: it should log a text event with parameters without error', () => { + return new Promise((resolve) => { + firebase.native.analytics().logEvent('test_event', { + boolean: true, + number: 1, + string: 'string', + }); + resolve(); + }); + }); + + it('setAnalyticsCollectionEnabled: it should run without error', () => { + return new Promise((resolve) => { + firebase.native.analytics().setAnalyticsCollectionEnabled(true); + resolve(); + }); + }); + + it('setCurrentScreen: it should run without error', () => { + return new Promise((resolve) => { + firebase.native.analytics().setCurrentScreen('test screen', 'test class override'); + resolve(); + }); + }); + + it('setMinimumSessionDuration: it should run without error', () => { + return new Promise((resolve) => { + firebase.native.analytics().setMinimumSessionDuration(10000); + resolve(); + }); + }); + + it('setSessionTimeoutDuration: it should run without error', () => { + return new Promise((resolve) => { + firebase.native.analytics().setSessionTimeoutDuration(1800000); + resolve(); + }); + }); + + it('setUserId: it should run without error', () => { + return new Promise((resolve) => { + firebase.native.analytics().setUserId('test-id'); + resolve(); + }); + }); + + it('setUserProperty: it should run without error', () => { + return new Promise((resolve) => { + firebase.native.analytics().setUserProperty('test-property', 'test-value'); + resolve(); + }); + }); + }); +} diff --git a/tests/src/tests/analytics/index.js b/tests/src/tests/analytics/index.js new file mode 100644 index 00000000..84a18d71 --- /dev/null +++ b/tests/src/tests/analytics/index.js @@ -0,0 +1,9 @@ +import firebase from '../../firebase'; +import TestSuite from '../../../lib/TestSuite'; +import analyticsTests from './analytics'; + +const suite = new TestSuite('Analytics', 'firebase.analytics()', firebase); + +suite.addTests(analyticsTests); + +export default suite; diff --git a/tests/src/tests/auth/authTests.js b/tests/src/tests/auth/authTests.js new file mode 100644 index 00000000..c9870069 --- /dev/null +++ b/tests/src/tests/auth/authTests.js @@ -0,0 +1,311 @@ +import should from 'should'; + +function randomString(length, chars) { + let mask = ''; + if (chars.indexOf('a') > -1) mask += 'abcdefghijklmnopqrstuvwxyz'; + if (chars.indexOf('A') > -1) mask += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; + if (chars.indexOf('#') > -1) mask += '0123456789'; + if (chars.indexOf('!') > -1) mask += '~`!@#$%^&*()_+-={}[]:";\'<>?,./|\\'; + let result = ''; + for (let i = length; i > 0; --i) result += mask[Math.round(Math.random() * (mask.length - 1))]; + return result; +} + +function authTests({ tryCatch, describe, it, firebase }) { + describe('Anonymous', () => { + it('it should sign in anonymously', () => { + const successCb = (currentUser) => { + currentUser.should.be.an.Object(); + currentUser.uid.should.be.a.String(); + currentUser.toJSON().should.be.an.Object(); + should.equal(currentUser.toJSON().email, null); + currentUser.isAnonymous.should.equal(true); + currentUser.providerId.should.equal('firebase'); + + firebase.native.auth().currentUser.uid.should.be.a.String(); + + return firebase.native.auth().signOut(); + }; + + return firebase.native.auth().signInAnonymously().then(successCb); + }); + }); + + describe('Link', () => { + it('it should link anonymous account <-> email account', () => { + const random = randomString(12, '#aA'); + const email = `${random}@${random}.com`; + const pass = random; + + const successCb = (currentUser) => { + currentUser.should.be.an.Object(); + currentUser.uid.should.be.a.String(); + currentUser.toJSON().should.be.an.Object(); + should.equal(currentUser.toJSON().email, null); + currentUser.isAnonymous.should.equal(true); + currentUser.providerId.should.equal('firebase'); + firebase.native.auth().currentUser.uid.should.be.a.String(); + + const credential = firebase.native.auth.EmailAuthProvider.credential(email, pass); + + return currentUser + .link(credential) + .then((linkedUser) => { + linkedUser.should.be.an.Object(); + linkedUser.uid.should.be.a.String(); + linkedUser.toJSON().should.be.an.Object(); + linkedUser.toJSON().email.should.eql(email); + linkedUser.isAnonymous.should.equal(false); + linkedUser.providerId.should.equal('firebase'); + return firebase.native.auth().signOut(); + }).catch((error) => { + return firebase.native.auth().signOut().then(() => { + return Promise.reject(error); + }); + }); + }; + + return firebase.native.auth().signInAnonymously().then(successCb); + }); + + it('it should error on link anon <-> email if email already exists', () => { + const email = 'test@test.com'; + const pass = 'test1234'; + + const successCb = (currentUser) => { + currentUser.should.be.an.Object(); + currentUser.uid.should.be.a.String(); + currentUser.toJSON().should.be.an.Object(); + should.equal(currentUser.toJSON().email, null); + currentUser.isAnonymous.should.equal(true); + currentUser.providerId.should.equal('firebase'); + firebase.native.auth().currentUser.uid.should.be.a.String(); + + const credential = firebase.native.auth.EmailAuthProvider.credential(email, pass); + + return currentUser + .link(credential) + .then(() => { + return firebase.native.auth().signOut().then(() => { + return Promise.reject(new Error('Did not error on link')); + }); + }).catch((error) => { + return firebase.native.auth().signOut().then(() => { + error.code.should.equal('auth/email-already-in-use'); + error.message.should.equal('The email address is already in use by another account.'); + return Promise.resolve(); + }); + }); + }; + + return firebase.native.auth().signInAnonymously().then(successCb); + }); + }); + + describe('Email - Login', () => { + it('it should login with email and password', () => { + const email = 'test@test.com'; + const pass = 'test1234'; + + const successCb = (currentUser) => { + currentUser.should.be.an.Object(); + currentUser.uid.should.be.a.String(); + currentUser.toJSON().should.be.an.Object(); + currentUser.toJSON().email.should.eql('test@test.com'); + currentUser.isAnonymous.should.equal(false); + currentUser.providerId.should.equal('firebase'); + + firebase.native.auth().currentUser.uid.should.be.a.String(); + + return firebase.native.auth().signOut(); + }; + + return firebase.native.auth().signInWithEmailAndPassword(email, pass).then(successCb); + }); + + it('it should error on login if user is disabled', () => { + const email = 'disabled@account.com'; + const pass = 'test1234'; + + const successCb = () => { + return Promise.reject(new Error('Did not error.')); + }; + + const failureCb = (error) => { + error.code.should.equal('auth/user-disabled'); + error.message.should.equal('The user account has been disabled by an administrator.'); + return Promise.resolve(); + }; + + return firebase.native.auth().signInWithEmailAndPassword(email, pass).then(successCb).catch(failureCb); + }); + + it('it should error on login if password incorrect', () => { + const email = 'test@test.com'; + const pass = 'test1234666'; + + const successCb = () => { + return Promise.reject(new Error('Did not error.')); + }; + + const failureCb = (error) => { + error.code.should.equal('auth/wrong-password'); + error.message.should.equal('The password is invalid or the user does not have a password.'); + return Promise.resolve(); + }; + + return firebase.native.auth().signInWithEmailAndPassword(email, pass).then(successCb).catch(failureCb); + }); + + it('it should error on login if user not found', () => { + const email = 'randomSomeone@fourOhFour.com'; + const pass = 'test1234'; + + const successCb = () => { + return Promise.reject(new Error('Did not error.')); + }; + + const failureCb = (error) => { + error.code.should.equal('auth/user-not-found'); + error.message.should.equal('There is no user record corresponding to this identifier. The user may have been deleted.'); + return Promise.resolve(); + }; + + return firebase.native.auth().signInWithEmailAndPassword(email, pass).then(successCb).catch(failureCb); + }); + }); + + describe('Email - Create', () => { + it('it should create a user with an email and password', () => { + const random = randomString(12, '#aA'); + const email = `${random}@${random}.com`; + const pass = random; + + const successCb = (newUser) => { + newUser.uid.should.be.a.String(); + newUser.email.should.equal(email.toLowerCase()); + newUser.emailVerified.should.equal(false); + newUser.isAnonymous.should.equal(false); + newUser.providerId.should.equal('firebase'); + }; + + return firebase.native.auth().createUserWithEmailAndPassword(email, pass).then(successCb); + }); + + it('it should error on create with invalid email', () => { + const random = randomString(12, '#aA'); + const email = `${random}${random}.com.boop.shoop`; + const pass = random; + + const successCb = () => { + return Promise.reject(new Error('Did not error.')); + }; + + const failureCb = (error) => { + error.code.should.equal('auth/invalid-email'); + error.message.should.equal('The email address is badly formatted.'); + return Promise.resolve(); + }; + + return firebase.native.auth().createUserWithEmailAndPassword(email, pass).then(successCb).catch(failureCb); + }); + + it('it should error on create if email in use', () => { + const email = 'test@test.com'; + const pass = 'test123456789'; + + const successCb = () => { + return Promise.reject(new Error('Did not error.')); + }; + + const failureCb = (error) => { + error.code.should.equal('auth/email-already-in-use'); + error.message.should.equal('The email address is already in use by another account.'); + return Promise.resolve(); + }; + + return firebase.native.auth().createUserWithEmailAndPassword(email, pass).then(successCb).catch(failureCb); + }); + + it('it should error on create if password weak', () => { + const email = 'testy@testy.com'; + const pass = '123'; + + const successCb = () => { + return Promise.reject(new Error('Did not error.')); + }; + + const failureCb = (error) => { + error.code.should.equal('auth/weak-password'); + // cannot test this message - it's different on the web client than ios/android return + // error.message.should.equal('The given password is invalid.'); + return Promise.resolve(); + }; + + return firebase.native.auth().createUserWithEmailAndPassword(email, pass).then(successCb).catch(failureCb); + }); + }); + + describe('Misc', () => { + it('it should delete a user', () => { + const random = randomString(12, '#aA'); + const email = `${random}@${random}.com`; + const pass = random; + + const successCb = (newUser) => { + newUser.uid.should.be.a.String(); + newUser.email.should.equal(email.toLowerCase()); + newUser.emailVerified.should.equal(false); + newUser.isAnonymous.should.equal(false); + newUser.providerId.should.equal('firebase'); + return firebase.native.auth().currentUser.delete(); + }; + + return firebase.native.auth().createUserWithEmailAndPassword(email, pass).then(successCb); + }); + + it('it should return a token via getToken', () => { + const random = randomString(12, '#aA'); + const email = `${random}@${random}.com`; + const pass = random; + + const successCb = (newUser) => { + newUser.uid.should.be.a.String(); + newUser.email.should.equal(email.toLowerCase()); + newUser.emailVerified.should.equal(false); + newUser.isAnonymous.should.equal(false); + newUser.providerId.should.equal('firebase'); + + return newUser.getToken().then((token) => { + token.should.be.a.String(); + token.length.should.be.greaterThan(24); + return firebase.native.auth().currentUser.delete(); + }); + }; + + return firebase.native.auth().createUserWithEmailAndPassword(email, pass).then(successCb); + }); + + it('it should reject signOut if no currentUser', () => { + return new Promise((resolve, reject) => { + if (firebase.native.auth().currentUser) { + return reject(new Error(`A user is currently signed in. ${firebase.native.auth().currentUser.uid}`)); + } + + const successCb = tryCatch(() => { + reject(new Error('No signOut error returned')); + }, reject); + + const failureCb = tryCatch((error) => { + error.code.should.equal('auth/no_current_user'); + error.message.should.equal('No user currently signed in.'); + resolve(); + }, reject); + + return firebase.native.auth().signOut().then(successCb).catch(failureCb); + }); + }); + }); +} + +export default authTests; diff --git a/tests/src/tests/auth/index.js b/tests/src/tests/auth/index.js new file mode 100644 index 00000000..fff18020 --- /dev/null +++ b/tests/src/tests/auth/index.js @@ -0,0 +1,10 @@ +import firebase from '../../firebase'; +import TestSuite from '../../../lib/TestSuite'; + +import authTests from './authTests'; + +const suite = new TestSuite('Auth', 'firebase.auth()', firebase); + +suite.addTests(authTests); + +export default suite; diff --git a/tests/src/tests/crash/index.js b/tests/src/tests/crash/index.js new file mode 100644 index 00000000..9755c28d --- /dev/null +++ b/tests/src/tests/crash/index.js @@ -0,0 +1,10 @@ +import firebase from '../../firebase'; +import TestSuite from '../../../lib/TestSuite'; +import logTests from './log'; + +const suite = new TestSuite('Crash', 'firebase.crash()', firebase); + +// bootstrap tests +suite.addTests(logTests); + +export default suite; diff --git a/tests/src/tests/crash/log.js b/tests/src/tests/crash/log.js new file mode 100644 index 00000000..c23787a7 --- /dev/null +++ b/tests/src/tests/crash/log.js @@ -0,0 +1,17 @@ +export default function addTests({ describe, it, firebase }) { + describe('Log', () => { + it('log: it should log without error', () => { + return new Promise((resolve) => { + firebase.native.crash().log('Test log'); + resolve(); + }); + }); + + it('logcat: it should log without error', () => { + return new Promise((resolve) => { + firebase.native.crash().logcat(0, 'LogTest', 'Test log'); + resolve(); + }); + }); + }); +} diff --git a/tests/src/tests/database/index.js b/tests/src/tests/database/index.js new file mode 100644 index 00000000..39cd7e85 --- /dev/null +++ b/tests/src/tests/database/index.js @@ -0,0 +1,21 @@ +import firebase from '../../firebase'; +import TestSuite from '../../../lib/TestSuite'; + +/* + Test suite files + */ + +import snapshotTests from './snapshot'; +import refTestGroups from './ref/index'; + +const suite = new TestSuite('Database', 'firebase.database()', firebase); + +/* + Register tests with test suite + */ + +suite.addTests(refTestGroups); +suite.addTests(snapshotTests); + +export default suite; + diff --git a/tests/src/tests/database/ref/childTests.js b/tests/src/tests/database/ref/childTests.js new file mode 100644 index 00000000..9a97c434 --- /dev/null +++ b/tests/src/tests/database/ref/childTests.js @@ -0,0 +1,69 @@ +function childTests({ describe, it, context, firebase }) { + describe('ref().child', () => { + context('when passed a shallow path', () => { + it('returns correct child ref', () => { + // Setup + + const ref = firebase.native.database().ref('tests'); + + // Test + + const childRef = ref.child('tests'); + + // Assertion + + childRef.key.should.eql('tests'); + }); + }); + + context('when passed a nested path', () => { + it('returns correct child ref', () => { + // Setup + + const ref = firebase.native.database().ref('tests'); + + // Test + + const grandChildRef = ref.child('tests/number'); + + // Assertion + + grandChildRef.key.should.eql('number'); + }); + }); + + context('when passed a path that doesn\'t exist', () => { + it('creates a reference, anyway', () => { + // Setup + + const ref = firebase.native.database().ref('tests'); + + // Test + + const grandChildRef = ref.child('doesnt/exist'); + + // Assertion + + grandChildRef.key.should.eql('exist'); + }); + }); + + context('when passed an invalid path', () => { + it('creates a reference, anyway', () => { + // Setup + + const ref = firebase.native.database().ref('tests'); + + // Test + + const grandChildRef = ref.child('does$&nt/exist'); + + // Assertion + + grandChildRef.key.should.eql('exist'); + }); + }); + }); +} + +export default childTests; diff --git a/tests/src/tests/database/ref/factoryTests.js b/tests/src/tests/database/ref/factoryTests.js new file mode 100644 index 00000000..3a4e0c1b --- /dev/null +++ b/tests/src/tests/database/ref/factoryTests.js @@ -0,0 +1,38 @@ +import DatabaseContents from '../../support/DatabaseContents'; + +function factoryTests({ describe, it, firebase }) { + describe('ref()', () => { + it('returns root reference when provided no path', () => { + // Setup + + const ref = firebase.native.database().ref(); + + // Test + + + // Assertion + + (ref.key === null).should.be.true(); + (ref.parent === null).should.be.true(); + }); + + it('returns reference to data at path', async () => { + // Setup + + const ref = firebase.native.database().ref('tests/types/number'); + + // Test + let valueAtRef; + + await ref.once('value', (snapshot) => { + valueAtRef = snapshot.val(); + }); + + // Assertion + + valueAtRef.should.eql(DatabaseContents.DEFAULT.number); + }); + }); +} + +export default factoryTests; diff --git a/tests/src/tests/database/ref/index.js b/tests/src/tests/database/ref/index.js new file mode 100644 index 00000000..15b7424d --- /dev/null +++ b/tests/src/tests/database/ref/index.js @@ -0,0 +1,43 @@ +import onTests from './onTests'; +import offTests from './offTests'; +import onceTests from './onceTests'; +import setTests from './setTests'; +import updateTests from './updateTests'; +import removeTests from './removeTests'; +import pushTests from './pushTests'; +import factoryTests from './factoryTests'; +import keyTests from './keyTests'; +import parentTests from './parentTests'; +import childTests from './childTests'; +import isEqualTests from './isEqualTests'; +import refTests from './refTests'; +import rootTests from './rootTests'; +import transactionTests from './transactionTests'; +import queryTests from './queryTests'; + +import DatabaseContents from '../../support/DatabaseContents'; + +const testGroups = [ + factoryTests, keyTests, parentTests, childTests, rootTests, + pushTests, onTests, offTests, onceTests, updateTests, removeTests, setTests, + transactionTests, queryTests, refTests, isEqualTests, +]; + +function registerTestSuite(testSuite) { + testSuite.beforeEach(async function () { + this._databaseRef = testSuite.firebase.native.database().ref('tests/types'); + + await this._databaseRef.set(DatabaseContents.DEFAULT); + }); + + testSuite.afterEach(async function () { + await this._databaseRef.set(DatabaseContents.DEFAULT); + }); + + testGroups.forEach((testGroup) => { + testGroup(testSuite); + }); +} + + +module.exports = registerTestSuite; diff --git a/tests/src/tests/database/ref/isEqualTests.js b/tests/src/tests/database/ref/isEqualTests.js new file mode 100644 index 00000000..3fee2a6a --- /dev/null +++ b/tests/src/tests/database/ref/isEqualTests.js @@ -0,0 +1,41 @@ +function isEqualTests({ describe, before, it, firebase }) { + describe('ref().isEqual()', () => { + before(() => { + this.ref = firebase.native.database().ref('tests/types'); + }); + + it('returns true when the reference is for the same location', () => { + // Setup + + const ref2 = firebase.native.database().ref('tests/types'); + + // Assertion + + this.ref.isEqual(ref2).should.eql(true); + }); + + it('returns false when the reference is for a different location', () => { + // Setup + + const ref2 = firebase.native.database().ref('tests/types/number'); + + // Assertion + + this.ref.isEqual(ref2).should.eql(false); + }); + + it('returns false when the reference is null', () => { + // Assertion + + this.ref.isEqual(null).should.eql(false); + }); + + it('returns false when the reference is not a Reference', () => { + // Assertion + + this.ref.isEqual(1).should.eql(false); + }); + }); +} + +export default isEqualTests; diff --git a/tests/src/tests/database/ref/keyTests.js b/tests/src/tests/database/ref/keyTests.js new file mode 100644 index 00000000..30b2aac0 --- /dev/null +++ b/tests/src/tests/database/ref/keyTests.js @@ -0,0 +1,30 @@ +function keyTests({ describe, it, firebase }) { + describe('ref().key', () => { + it('returns null for root ref', () => { + // Setup + + const ref = firebase.native.database().ref(); + + // Test + + + // Assertion + + (ref.key === null).should.be.true(); + }); + + it('returns correct key for path', () => { + // Setup + + const ref = firebase.native.database().ref('tests/types/number'); + const arrayItemRef = firebase.native.database().ref('tests/types/array/1'); + + // Assertion + + ref.key.should.eql('number'); + arrayItemRef.key.should.eql('1'); + }); + }); +} + +export default keyTests; diff --git a/tests/src/tests/database/ref/offTests.js b/tests/src/tests/database/ref/offTests.js new file mode 100644 index 00000000..7fae0d8b --- /dev/null +++ b/tests/src/tests/database/ref/offTests.js @@ -0,0 +1,276 @@ +import should from 'should'; +import sinon from 'sinon'; + +import DatabaseContents from '../../support/DatabaseContents'; + +function offTests({ describe, it, xit, xcontext, context, firebase }) { + + describe('ref().off()', () => { + xit('doesn\'t unbind children callbacks', async () => { + // Setup + + const parentCallback = sinon.spy(); + const childCallback = sinon.spy(); + + const parentRef = firebase.native.database().ref('tests/types'); + const childRef = firebase.native.database().ref('tests/types/string'); + + await new Promise((resolve) => { + parentRef.on('value', () => { + parentCallback(); + resolve(); + }); + }); + + await new Promise((resolve) => { + childRef.on('value', () => { + childCallback(); + resolve(); + }); + }); + + parentCallback.should.be.calledOnce(); + childCallback.should.be.calledOnce(); + + // Returns nothing + should(parentRef.off(), undefined); + + // Trigger event parent callback is listening to + await parentRef.set(DatabaseContents.DEFAULT); + + // parent and child callbacks should not have been called any more + parentCallback.should.be.calledOnce(); + childCallback.should.be.calledOnce(); + + // Trigger event child callback is listening to + await childRef.set(DatabaseContents.DEFAULT.string); + + // child callback should still be listening + childCallback.should.be.calledOnce(); + + // Teardown + childRef.off(); + }); + + context('when passed no arguments', () => { + context('and there are no callbacks bound', () => { + it('does nothing', () => { + const ref = firebase.native.database().ref('tests/types/array'); + + should(ref.off(), undefined); + }); + }); + + it('stops all callbacks listening for all changes', async () => { + // Setup + + const valueCallback = sinon.spy(); + const childAddedCallback = sinon.spy(); + + const ref = firebase.native.database().ref('tests/types/array'); + const arrayLength = DatabaseContents.DEFAULT.array.length; + + await new Promise((resolve) => { + ref.on('value', () => { + valueCallback(); + resolve(); + }); + }); + + await new Promise((resolve) => { + ref.on('child_added', () => { + childAddedCallback(); + resolve(); + }); + }); + + valueCallback.should.be.calledOnce(); + childAddedCallback.should.have.callCount(arrayLength); + + // Check childAddedCallback is really attached + await ref.push(DatabaseContents.DEFAULT.number); + childAddedCallback.should.be.callCount(arrayLength + 1); + + // Returns nothing + should(ref.off(), undefined); + + // Trigger both callbacks + + await ref.set(DatabaseContents.DEFAULT.array); + await ref.push(DatabaseContents.DEFAULT.number); + + // Callbacks should have been unbound and not called again + valueCallback.should.be.calledOnce(); + childAddedCallback.should.be.callCount(arrayLength + 1); + }); + }); + + context('when passed an event type', () => { + context('and there are no callbacks bound', () => { + it('does nothing', () => { + const ref = firebase.native.database().ref('tests/types/array'); + + should(ref.off('value'), undefined); + }); + }); + + context('that is invalid', () => { + it('does nothing', () => { + const ref = firebase.native.database().ref('tests/types/array'); + + should(ref.off('invalid'), undefined); + }); + }); + + xit('detaches all callbacks listening for that event', async () => { + // Setup + + const callbackA = sinon.spy(); + const callbackB = sinon.spy(); + + const ref = firebase.native.database().ref('tests/types/string'); + + await new Promise((resolve) => { + ref.on('value', () => { + callbackA(); + resolve(); + }); + }); + + await new Promise((resolve) => { + ref.on('value', () => { + callbackB(); + resolve(); + }); + }); + + callbackA.should.be.calledOnce(); + callbackB.should.be.calledOnce(); + + // Returns nothing + should(ref.off('value'), undefined); + + // Assertions + + await ref.set(DatabaseContents.DEFAULT.string); + + // Callbacks should have been unbound and not called again + callbackA.should.be.calledOnce(); + callbackB.should.be.calledOnce(); + }); + }); + + context('when passed a particular callback', () => { + context('and there are no callbacks bound', () => { + it('does nothing', () => { + const ref = firebase.native.database().ref('tests/types/array'); + + should(ref.off('value', sinon.spy()), undefined); + }); + }); + + xit('detaches only that callback', async () => { + // Setup + + const callbackA = sinon.spy(); + const callbackB = sinon.spy(); + + const ref = firebase.native.database().ref('tests/types/string'); + + // Attach the callback the first time + await new Promise((resolve) => { + ref.on('value', () => { + callbackA(); + resolve(); + }); + }); + + // Attach the callback the second time + await new Promise((resolve) => { + ref.on('value', () => { + callbackB(); + resolve(); + }); + }); + + callbackA.should.be.calledOnce(); + callbackB.should.be.calledOnce(); + + // Detach callbackA, only + should(ref.off('value', callbackA), undefined); + + // Trigger the event the callback is listening to + await ref.set(DatabaseContents.DEFAULT.string); + + // CallbackB should still be attached + callbackA.should.be.calledOnce(); + callbackB.should.be.calledTwice(); + + // Teardown + should(ref.off('value', callbackB), undefined); + }); + + context('that has been added multiple times', () => { + xit('must be called as many times completely remove', async () => { + // Setup + + const callbackA = sinon.spy(); + + const ref = firebase.native.database().ref('tests/types/string'); + + // Attach the callback the first time + await new Promise((resolve) => { + ref.on('value', () => { + callbackA(); + resolve(); + }); + }); + + // Attach the callback the second time + await new Promise((resolve) => { + ref.on('value', () => { + callbackA(); + resolve(); + }); + }); + + callbackA.should.be.calledTwice(); + + // Undo the first time the callback was attached + should(ref.off(), undefined); + + // Trigger the event the callback is listening to + await ref.set(DatabaseContents.DEFAULT.number); + + // Callback should have been called only once because one of the attachments + // has been removed + callbackA.should.be.calledThrice(); + + // Undo the second attachment + should(ref.off(), undefined); + + // Trigger the event the callback is listening to + await ref.set(DatabaseContents.DEFAULT.number); + + // Callback should not have been called any more times + callbackA.should.be.calledThrice(); + }); + }); + }); + + xcontext('when a context', () => { + /** + * @todo Add tests for when a context is passed. Not sure what the intended + * behaviour is as the documentation is unclear, but assumption is that as the + * context is not required to unbind a listener, it's used as a filter parameter + * so in order for off() to remove a callback, the callback must have been bound + * with the same event type, callback function and context. + * + * Needs to be tested against web implementation, if possible. + */ + + }); + }); +} + +export default offTests; diff --git a/tests/src/tests/database/ref/onTests.js b/tests/src/tests/database/ref/onTests.js new file mode 100644 index 00000000..8f01708b --- /dev/null +++ b/tests/src/tests/database/ref/onTests.js @@ -0,0 +1,125 @@ +import sinon from 'sinon'; +import 'should-sinon'; +import Promise from 'bluebird'; + +import DatabaseContents from '../../support/DatabaseContents'; + +function onTests({ describe, it, firebase, tryCatch }) { + describe('ref().on()', () => { + it('calls callback when value changes', () => { + return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => { + // Setup + + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + const currentDataValue = DatabaseContents.DEFAULT[dataRef]; + + const callback = sinon.spy(); + + // Test + + await new Promise((resolve) => { + ref.on('value', (snapshot) => { + callback(snapshot.val()); + resolve(); + }); + }); + + callback.should.be.calledWith(currentDataValue); + + const newDataValue = DatabaseContents.NEW[dataRef]; + await ref.set(newDataValue); + + // Assertions + + callback.should.be.calledWith(newDataValue); + + // Tear down + + ref.off(); + }); + }); + + it('allows binding multiple callbacks to the same ref', () => { + return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => { + // Setup + + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + const currentDataValue = DatabaseContents.DEFAULT[dataRef]; + + const callbackA = sinon.spy(); + const callbackB = sinon.spy(); + + // Test + + await new Promise((resolve) => { + ref.on('value', (snapshot) => { + callbackA(snapshot.val()); + resolve(); + }); + }); + + await new Promise((resolve) => { + ref.on('value', (snapshot) => { + callbackB(snapshot.val()); + resolve(); + }); + }); + + callbackA.should.be.calledWith(currentDataValue); + callbackB.should.be.calledWith(currentDataValue); + + // Tear down + + ref.off(); + }); + }); + + it('calls callback with current values', () => { + return Promise.each(Object.keys(DatabaseContents.DEFAULT), (dataRef) => { + // Setup + + const dataTypeValue = DatabaseContents.DEFAULT[dataRef]; + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + + // Test + + return ref.on('value', (snapshot) => { + // Assertion + + snapshot.val().should.eql(dataTypeValue); + + // Tear down + + ref.off(); + }); + }); + }); + + it('errors if permission denied', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch(() => { + // Assertion + + reject(new Error('No permission denied error')); + }, reject); + + const failureCb = tryCatch((error) => { + // Assertion + + error.message.includes('permission_denied').should.be.true(); + resolve(); + }, reject); + + // Setup + + const invalidRef = firebase.native.database().ref('nope'); + + // Test + + invalidRef.on('value', successCb, failureCb); + }); + }); + }); +} + +export default onTests; diff --git a/tests/src/tests/database/ref/onceTests.js b/tests/src/tests/database/ref/onceTests.js new file mode 100644 index 00000000..6b5ee6b6 --- /dev/null +++ b/tests/src/tests/database/ref/onceTests.js @@ -0,0 +1,81 @@ +import sinon from 'sinon'; +import 'should-sinon'; + +import DatabaseContents from '../../support/DatabaseContents'; + +function onceTests({ describe, firebase, it, tryCatch }) { + describe('ref().once()', () => { + it('returns a promise', () => { + // Setup + + const ref = firebase.native.database().ref('tests/types/number'); + + // Test + + const returnValue = ref.once('value'); + + // Assertion + + returnValue.should.be.Promise(); + }); + + it('resolves with the correct value', async () => { + await Promise.map(Object.keys(DatabaseContents.DEFAULT), (dataRef) => { + // Setup + + const dataTypeValue = DatabaseContents.DEFAULT[dataRef]; + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + + // Test + + return ref.once('value').then((snapshot) => { + // Assertion + + snapshot.val().should.eql(dataTypeValue); + }); + }); + }); + + it('is NOT called when the value is changed', async () => { + // Setup + + const callback = sinon.spy(); + const ref = firebase.native.database().ref('tests/types/number'); + + // Test + + ref.once('value').then(callback); + + await ref.set(DatabaseContents.NEW.number); + + // Assertion + callback.should.be.calledOnce(); + }); + + it('errors if permission denied', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch(() => { + // Assertion + + reject(new Error('No permission denied error')); + }, reject); + + const failureCb = tryCatch((error) => { + // Assertion + + error.message.includes('permission_denied').should.be.true(); + resolve(); + }, reject); + + // Setup + + const reference = firebase.native.database().ref('nope'); + + // Test + reference.once('value', successCb, failureCb); + }); + }); + }); +} + +export default onceTests; diff --git a/tests/src/tests/database/ref/parentTests.js b/tests/src/tests/database/ref/parentTests.js new file mode 100644 index 00000000..95ec2d03 --- /dev/null +++ b/tests/src/tests/database/ref/parentTests.js @@ -0,0 +1,33 @@ +function parentTests({ describe, context, it, firebase }) { + describe('ref().parent', () => { + context('on the root ref', () => { + it('returns null', () => { + // Setup + + const ref = firebase.native.database().ref(); + + // Test + + + // Assertion + + (ref.parent === null).should.be.true(); + }); + }); + + context('on a non-root ref', () => { + it('returns correct parent', () => { + // Setup + + const ref = firebase.native.database().ref('tests/types/number'); + const parentRef = firebase.native.database().ref('tests/types'); + + // Assertion + + ref.parent.key.should.eql(parentRef.key); + }); + }); + }); +} + +export default parentTests; diff --git a/tests/src/tests/database/ref/pushTests.js b/tests/src/tests/database/ref/pushTests.js new file mode 100644 index 00000000..063ce35c --- /dev/null +++ b/tests/src/tests/database/ref/pushTests.js @@ -0,0 +1,113 @@ +import sinon from 'sinon'; +import 'should-sinon'; + +import DatabaseContents from '../../support/DatabaseContents'; + +function pushTests({ describe, it, firebase }) { + describe('ref().push()', () => { + it('returns a ref that can be used to set value later', async () => { + // Setup + + const ref = firebase.native.database().ref('tests/types/array'); + + let originalListValue; + + await ref.once('value', (snapshot) => { + originalListValue = snapshot.val(); + }); + + originalListValue.should.eql(DatabaseContents.DEFAULT.array); + + // Test + + const newItemRef = ref.push(); + + const valueToAddToList = DatabaseContents.NEW.number; + await newItemRef.set(valueToAddToList); + + let newItemValue, + newListValue; + + // Assertion + + await newItemRef.once('value', (snapshot) => { + newItemValue = snapshot.val(); + }); + + newItemValue.should.eql(valueToAddToList); + + await ref.once('value', (snapshot) => { + newListValue = snapshot.val(); + }); + + const originalListAsObject = originalListValue.reduce((memo, value, index) => { + memo[index] = value; + return memo; + }, {}); + + originalListAsObject[newItemRef.key] = valueToAddToList; + + newListValue.should.eql(originalListAsObject); + }); + + it('allows setting value immediately', async () => { + // Setup + + const ref = firebase.native.database().ref('tests/types/array'); + + let originalListValue; + + await ref.once('value', (snapshot) => { + originalListValue = snapshot.val(); + }); + + // Test + + const valueToAddToList = DatabaseContents.NEW.number; + const newItemRef = await ref.push(valueToAddToList); + + let newItemValue, + newListValue; + + // Assertion + + await newItemRef.once('value', (snapshot) => { + newItemValue = snapshot.val(); + }); + + newItemValue.should.eql(valueToAddToList); + + await ref.once('value', (snapshot) => { + newListValue = snapshot.val(); + }); + + const originalListAsObject = originalListValue.reduce((memo, value, index) => { + memo[index] = value; + return memo; + }, {}); + + originalListAsObject[newItemRef.key] = valueToAddToList; + + newListValue.should.eql(originalListAsObject); + }); + + it('calls an onComplete callback', async () => { + // Setup + + const callback = sinon.spy(); + + const ref = firebase.native.database().ref('tests/types/array'); + + // Test + + const valueToAddToList = DatabaseContents.NEW.number; + await ref.push(valueToAddToList, callback); + + // Assertion + + callback.should.be.calledWith(null); + }); + }) +} + +export default pushTests; diff --git a/tests/src/tests/database/ref/queryTests.js b/tests/src/tests/database/ref/queryTests.js new file mode 100644 index 00000000..5282fb97 --- /dev/null +++ b/tests/src/tests/database/ref/queryTests.js @@ -0,0 +1,25 @@ +import 'should-sinon'; +import Promise from 'bluebird'; + +function queryTests({ describe, it, firebase, tryCatch }) { + describe('ref query', () => { + it('orderByChild().equalTo()', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + const webVal = snapshot.val(); + const ref = firebase.native.database().ref('tests/query'); + + ref.orderByChild('search').equalTo('foo').once('value', tryCatch((snapshot) => { + const nativeVal = snapshot.val(); + nativeVal.should.eql(webVal); + resolve(); + }, reject), reject); + }, reject); + + firebase.web.database().ref('tests/query').orderByChild('search').equalTo('foo').once('value', successCb, reject); + }); + }); + }); +} + +export default queryTests; diff --git a/tests/src/tests/database/ref/refTests.js b/tests/src/tests/database/ref/refTests.js new file mode 100644 index 00000000..7d3517ec --- /dev/null +++ b/tests/src/tests/database/ref/refTests.js @@ -0,0 +1,15 @@ +function refTests({ describe, it, firebase }) { + describe('ref().ref', () => { + it('returns a the reference itself', () => { + // Setup + + const ref = firebase.native.database().ref(); + + // Assertion + + ref.ref.should.eql(ref); + }); + }); +} + +export default refTests; diff --git a/tests/src/tests/database/ref/removeTests.js b/tests/src/tests/database/ref/removeTests.js new file mode 100644 index 00000000..701fecd2 --- /dev/null +++ b/tests/src/tests/database/ref/removeTests.js @@ -0,0 +1,44 @@ +import DatabaseContents from '../../support/DatabaseContents'; + +function removeTests({ describe, it, firebase }) { + describe('ref().remove()', () => { + it('returns a promise', () => { + // Setup + + const ref = firebase.native.database().ref('tests/types'); + + // Test + + const returnValue = ref.remove({ number: DatabaseContents.DEFAULT.number }); + + // Assertion + + returnValue.should.be.Promise(); + }); + + it('sets value to null', async () => { + await Promise.map(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => { + // Setup + + const previousValue = DatabaseContents.DEFAULT[dataRef]; + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + + await ref.once('value').then((snapshot) => { + snapshot.val().should.eql(previousValue); + }); + + // Test + + await ref.remove(); + + // Assertion + + await ref.once('value').then((snapshot) => { + (snapshot.val() === null).should.be.true(); + }); + }); + }); + }); +} + +export default removeTests; diff --git a/tests/src/tests/database/ref/rootTests.js b/tests/src/tests/database/ref/rootTests.js new file mode 100644 index 00000000..d95b2438 --- /dev/null +++ b/tests/src/tests/database/ref/rootTests.js @@ -0,0 +1,36 @@ +function rootTests({ describe, it, context, firebase }) { + describe('ref().root', () => { + context('when called on a non-root reference', () => { + it('returns root ref', () => { + // Setup + + const rootRef = firebase.native.database().ref(); + const nonRootRef = firebase.native.database().ref('tests/types/number'); + + // Test + + + // Assertion + + nonRootRef.root.should.eql(rootRef); + }); + }); + + context('when called on the root reference', () => { + it('returns root ref', () => { + // Setup + + const rootRef = firebase.native.database().ref(); + + // Test + + + // Assertion + + rootRef.root.should.eql(rootRef); + }); + }); + }); +} + +export default rootTests; diff --git a/tests/src/tests/database/ref/setTests.js b/tests/src/tests/database/ref/setTests.js new file mode 100644 index 00000000..1275664f --- /dev/null +++ b/tests/src/tests/database/ref/setTests.js @@ -0,0 +1,73 @@ +import DatabaseContents from '../../support/DatabaseContents'; + +function setTests({ describe, it, xit, firebase }) { + describe('ref.set()', () => { + xit('returns a promise', async () => { + // Setup + + const ref = firebase.native.database().ref('tests/types/number'); + + // Test + + const returnValue = ref.set(DatabaseContents.DEFAULT.number); + + // Assertion + + returnValue.should.be.Promise(); + + await returnValue.then((value) => { + (value === undefined).should.be.true(); + }); + }); + + it('changes value', async () => { + await Promise.map(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => { + // Setup + + const previousValue = DatabaseContents.DEFAULT[dataRef]; + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + + await ref.once('value').then((snapshot) => { + snapshot.val().should.eql(previousValue); + }); + + const newValue = DatabaseContents.NEW[dataRef]; + + // Test + + await ref.set(newValue); + + await ref.once('value').then((snapshot) => { + // Assertion + + snapshot.val().should.eql(newValue); + }); + }); + }); + + it('can unset values', async () => { + await Promise.map(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => { + // Setup + + const previousValue = DatabaseContents.DEFAULT[dataRef]; + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + + await ref.once('value').then((snapshot) => { + snapshot.val().should.eql(previousValue); + }); + + // Test + + await ref.set(null); + + await ref.once('value').then((snapshot) => { + // Assertion + + (snapshot.val() === null).should.be.true(); + }); + }); + }); + }); +} + +export default setTests; diff --git a/tests/src/tests/database/ref/transactionTests.js b/tests/src/tests/database/ref/transactionTests.js new file mode 100644 index 00000000..f37682b0 --- /dev/null +++ b/tests/src/tests/database/ref/transactionTests.js @@ -0,0 +1,53 @@ +import Promise from 'bluebird'; + +function onTests({ describe, it, firebase, tryCatch }) { + describe('ref.transaction()', () => { + it('works', () => { + return new Promise((resolve, reject) => { + let valueBefore = 1; + + firebase.native.database() + .ref('tests/transaction').transaction((currentData) => { + if (currentData === null) { + return valueBefore + 10; + } + valueBefore = currentData; + return valueBefore + 10; + }, tryCatch((error, committed, snapshot) => { + if (error) { + return reject(error); + } + + if (!committed) { + return reject(new Error('Transaction did not commit.')); + } + + snapshot.val().should.equal(valueBefore + 10); + + return resolve(); + }, reject), true); + }); + }); + + it('aborts if undefined returned', () => { + return new Promise((resolve, reject) => { + firebase.native.database() + .ref('tests/transaction').transaction(() => { + return undefined; + }, (error, committed) => { + if (error) { + return reject(error); + } + + if (!committed) { + return resolve(); + } + + return reject(new Error('Transaction did not abort commit.')); + }, true); + }); + }); + }); +} + +export default onTests; diff --git a/tests/src/tests/database/ref/updateTests.js b/tests/src/tests/database/ref/updateTests.js new file mode 100644 index 00000000..09af4383 --- /dev/null +++ b/tests/src/tests/database/ref/updateTests.js @@ -0,0 +1,112 @@ +import Promise from 'bluebird'; +import DatabaseContents from '../../support/DatabaseContents'; + +function updateTests({ describe, it, firebase }) { + describe('ref().update()', () => { + it('returns a promise', () => { + // Setup + + const ref = firebase.native.database().ref('tests/types'); + + // Test + + const returnValue = ref.update({ number: DatabaseContents.DEFAULT.number }); + + // Assertion + + returnValue.should.be.Promise(); + }); + + it('changes value', () => { + return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => { + // Setup + + const previousValue = DatabaseContents.DEFAULT[dataRef]; + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + + await ref.once('value').then((snapshot) => { + snapshot.val().should.eql(previousValue); + }); + + const newValue = DatabaseContents.NEW[dataRef]; + const parentRef = firebase.native.database().ref('tests/types'); + + // Test + + await parentRef.update({ [dataRef]: newValue }); + + // Assertion + + await ref.once('value').then((snapshot) => { + snapshot.val().should.eql(newValue); + }); + }); + }); + + it('can unset values', () => { + return Promise.each(Object.keys(DatabaseContents.DEFAULT), async (dataRef) => { + // Setup + + const previousValue = DatabaseContents.DEFAULT[dataRef]; + const ref = firebase.native.database().ref(`tests/types/${dataRef}`); + + await ref.once('value').then((snapshot) => { + snapshot.val().should.eql(previousValue); + }); + + const parentRef = firebase.native.database().ref('tests/types'); + + // Test + + await parentRef.update({ [dataRef]: null }); + + // Assertion + + await ref.once('value').then((snapshot) => { + (snapshot.val() === null).should.be.true(); + }); + }); + }); + + it('updates multiple values at once', async () => { + // Setup + + const numberPreviousValue = DatabaseContents.DEFAULT.number; + const stringPreviousValue = DatabaseContents.DEFAULT.string; + + const numberRef = firebase.native.database().ref('tests/types/number'); + const stringRef = firebase.native.database().ref('tests/types/string'); + + await numberRef.once('value').then((snapshot) => { + snapshot.val().should.eql(numberPreviousValue); + }); + + await stringRef.once('value').then((snapshot) => { + snapshot.val().should.eql(stringPreviousValue); + }); + + const numberNewValue = DatabaseContents.NEW.number; + const stringNewValue = DatabaseContents.NEW.string; + const parentRef = firebase.native.database().ref('tests/types'); + + // Test + + await parentRef.update({ + number: numberNewValue, + string: stringNewValue, + }); + + // Assertion + + await numberRef.once('value').then((snapshot) => { + snapshot.val().should.eql(numberNewValue); + }); + + await stringRef.once('value').then((snapshot) => { + snapshot.val().should.eql(stringNewValue); + }); + }); + }); +} + +export default updateTests; diff --git a/tests/src/tests/database/snapshot.js b/tests/src/tests/database/snapshot.js new file mode 100644 index 00000000..04dc5940 --- /dev/null +++ b/tests/src/tests/database/snapshot.js @@ -0,0 +1,116 @@ +export default function addTests({ tryCatch, describe, it, firebase }) { + describe('Snapshot', () => { + it('should provide a functioning val() method', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + snapshot.val.should.be.a.Function(); + snapshot.val().should.eql([ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + ]); + resolve(); + }, reject); + + firebase.native.database().ref('tests/types/array').once('value', successCb, reject); + }); + }); + + it('should provide a functioning child() method', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + snapshot.child('0').val.should.be.a.Function(); + snapshot.child('0').val().should.equal(0); + snapshot.child('0').key.should.be.a.String(); + snapshot.child('0').key.should.equal('0'); + resolve(); + }, reject); + + firebase.native.database().ref('tests/types/array').once('value', successCb, reject); + }); + }); + + it('should provide a functioning hasChild() method', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + snapshot.hasChild.should.be.a.Function(); + snapshot.hasChild('foo').should.equal(true); + snapshot.hasChild('baz').should.equal(false); + resolve(); + }, reject); + + firebase.native.database().ref('tests/types/object').once('value', successCb, reject); + }); + }); + + it('should provide a functioning hasChildren() method', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + snapshot.hasChildren.should.be.a.Function(); + snapshot.hasChildren().should.equal(true); + snapshot.child('foo').hasChildren().should.equal(false); + resolve(); + }, reject); + + firebase.native.database().ref('tests/types/object').once('value', successCb, reject); + }); + }); + + it('should provide a functioning exists() method', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + snapshot.exists.should.be.a.Function(); + snapshot.exists().should.equal(false); + resolve(); + }, reject); + + firebase.native.database().ref('tests/types/object/baz/daz').once('value', successCb, reject); + }); + }); + + it('should provide a functioning getPriority() method', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + snapshot.getPriority.should.be.a.Function(); + snapshot.getPriority().should.equal(666); + snapshot.val().should.eql({ foo: 'bar' }); + resolve(); + }, reject); + + const ref = firebase.native.database().ref('tests/priority'); + ref.once('value', successCb, reject); + }); + }); + + it('should provide a functioning forEach() method', () => { + // TODO this doesn't really test that the key order returned is in correct order + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + let total = 0; + snapshot.forEach.should.be.a.Function(); + snapshot.forEach((childSnapshot) => { + const val = childSnapshot.val(); + total = total + val; + return val === 3; // stop iteration after key 3 + }); + + total.should.equal(6); // 0 + 1 + 2 + 3 = 6 + resolve(); + }, reject); + + firebase.native.database().ref('tests/types/array').once('value', successCb, reject); + }); + }); + + it('should provide a key property', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((snapshot) => { + snapshot.key.should.be.a.String(); + snapshot.key.should.equal('array'); + resolve(); + }, reject); + + firebase.native.database().ref('tests/types/array').once('value', successCb, reject); + }); + }); + }); + +} diff --git a/tests/src/tests/index.js b/tests/src/tests/index.js new file mode 100644 index 00000000..806f411e --- /dev/null +++ b/tests/src/tests/index.js @@ -0,0 +1,216 @@ +import { setSuiteStatus, setTestStatus } from '../actions/TestActions'; +import analytics from './analytics/index'; +import crash from './crash/index'; +import database from './database/index'; +import messaging from './messaging/index'; +import storage from './storage/index'; +import auth from './auth/index'; + +const testSuiteInstances = [ + database, + auth, + analytics, + messaging, + crash, + storage, +]; + +/* + A map of test suite instances to their ids so they may be retrieved + at run time and called upon to run individual tests + */ +const testSuiteRunners = {}; + +/* + Attributes to hold initial Redux store state + */ +const testSuites = {}; +const tests = {}; +const focusedTestIds = {}; +const pendingTestIds = {}; +const testContexts = {}; + +/** + * @typedef {number} TestId + * @typedef {number} TestSuiteId + * + * @typedef {Object} Test + * @property {number} id + * @property {number} testSuiteId + * + * @typedef {Object} TestSuite + * @property {number} id + * @property {TestId[]} testIds + * + * @typedef {Object.} IndexedTestGroup + * @typedef {Object.} IndexedTestSuiteGroup + * @typedef {Object.} IdLookup + */ + +/** + * Return initial state for the tests to provide to Redux + * @returns {{suites: {}, descriptions: {}}} + */ +export function initialState() { + testSuiteInstances.forEach((testSuite) => { + const { id, name, description } = testSuite; + + // Add to test suite runners for later recall + testSuiteRunners[testSuite.id] = testSuite; + + const testDefinitions = testSuite.testDefinitions; + + // Add to test suites to place in the redux store + testSuites[testSuite.id] = { + id, + name, + description, + + testContextIds: Object.keys(testDefinitions.testContexts), + testIds: Object.keys(testDefinitions.tests), + + status: null, + message: null, + time: 0, + progress: 0, + }; + + Object.assign(tests, testDefinitions.tests); + Object.assign(testContexts, testDefinitions.testContexts); + Object.assign(focusedTestIds, testDefinitions.focusedTestIds); + Object.assign(pendingTestIds, testDefinitions.pendingTestIds); + }); + + return { + tests, + testSuites, + testContexts, + focusedTestIds, + pendingTestIds, + }; +} + +/** + * Provide a redux store to the test suites + * @param store + */ +export function setupSuites(store) { + Object.values(testSuiteRunners).forEach((testSuite) => { + // eslint-disable-next-line no-param-reassign + testSuite.setStore(store, (action) => { + store.dispatch(setSuiteStatus(action)); + }, (action) => { + store.dispatch(setTestStatus(action)); + }); + }); +} + +/** + * Run a single test by id, ignoring whether it's pending or focused. + * @param {number} testId - id of test to run + */ +export function runTest(testId) { + const test = tests[testId]; + + runTests({ [testId]: test }); +} + +/** + * Run all tests in all test suites. If testIds is provided, only run the tests + * that match the ids included. + * @params {IndexedTestGroup} testGroup - Group of tests to run + * @param {Object=} options - options limiting which tests should be run + * @param {IdLookup} options.pendingTestIds - map of ids of pending tests + * @param {IdLookup} options.focusedTestIds - map of ids of focused tests + */ +export function runTests(testGroup, options = { pendingTestIds: {}, focusedTestIds: {} }) { + const areFocusedTests = Object.keys(options.focusedTestIds).length > 0; + + if (areFocusedTests) { + runOnlyTestsInLookup(testGroup, options.focusedTestIds); + } else { + const arePendingTests = Object.keys(options.pendingTestIds).length > 0; + + if (arePendingTests) { + runAllButTestsInLookup(testGroup, options.pendingTestIds); + } else { + const testsBySuiteId = getTestsBySuiteId(testGroup); + runTestsBySuiteId(testsBySuiteId); + } + } +} + +/** + * Runs all tests listed in tests, except those with ids matching values in + * testLookup + * @param {IndexedTestGroup} testGroup - complete list of tests + * @param {IdLookup} testLookup - id lookup of pending tests + */ +function runAllButTestsInLookup(testGroup, testLookup) { + const testsToRunBySuiteId = Object.keys(testGroup).reduce((memo, testId) => { + const testIsNotPending = !testLookup[testId]; + + if (testIsNotPending) { + const test = testGroup[testId]; + // eslint-disable-next-line no-param-reassign + memo[test.testSuiteId] = memo[test.testSuiteId] || []; + memo[test.testSuiteId].push(testId); + } + + return memo; + }, {}); + + Promise.each(Object.keys(testsToRunBySuiteId), (testSuiteId) => { + const testIds = testsToRunBySuiteId[testSuiteId]; + return runSuite(testSuiteId, testIds); + }); +} + +/** + * Runs only the tests listed in focused tests + * @param {IndexedTestGroup} testGroup - complete list of tests + * @param {IdLookup} testLookup - id lookup of focused tests + */ +function runOnlyTestsInLookup(testGroup, testLookup) { + const testsInLookupBySuiteId = getTestsBySuiteId(testGroup, testLookup); + runTestsBySuiteId(testsInLookupBySuiteId); +} + +function runTestsBySuiteId(suiteIdTests) { + Promise.each(Object.keys(suiteIdTests), (testSuiteId) => { + const testIds = suiteIdTests[testSuiteId]; + + return runSuite(testSuiteId, testIds); + }); +} + +/** + * Run tests in a suite. If testIds is provided, only run the tests that match the + * ids included. + * @param {number} testSuiteId - Id of test suite to run + * @param {number[]=} testIds - array of test ids to run from the test suite + */ +function runSuite(testSuiteId, testIds = null) { + const testSuiteRunner = testSuiteRunners[testSuiteId]; + + if (testSuiteRunner) { + return testSuiteRunner.run(testIds); + } + + console.error(`runSuite: Suite with id "${testSuiteId}" not found`); + return Promise.reject(); +} + +function getTestsBySuiteId(testGroup, testLookup = testGroup) { + return Object.keys(testLookup).reduce((memo, testId) => { + const test = testGroup[testId]; + + if (test) { + // eslint-disable-next-line no-param-reassign + memo[test.testSuiteId] = memo[test.testSuiteId] || []; + memo[test.testSuiteId].push(testId); + } + + return memo; + }, {}); +} diff --git a/tests/src/tests/messaging/index.js b/tests/src/tests/messaging/index.js new file mode 100644 index 00000000..ee8ba50a --- /dev/null +++ b/tests/src/tests/messaging/index.js @@ -0,0 +1,10 @@ +import firebase from '../../firebase'; +import TestSuite from '../../../lib/TestSuite'; + +import messagingTests from './messagingTests'; + +const suite = new TestSuite('Messaging', 'firebase.messaging()', firebase); + +suite.addTests(messagingTests); + +export default suite; diff --git a/tests/src/tests/messaging/messagingTests.js b/tests/src/tests/messaging/messagingTests.js new file mode 100644 index 00000000..fa5ae579 --- /dev/null +++ b/tests/src/tests/messaging/messagingTests.js @@ -0,0 +1,149 @@ +function messagingTests({ describe, it, firebase }) { + describe('FCM', () => { + it('it should build a RemoteMessage', () => { + const remoteMessage = new firebase.native.messaging.RemoteMessage('305229645282'); + + // all optional + remoteMessage.setId('foobar'); + remoteMessage.setTtl(12000); + remoteMessage.setType('something'); + remoteMessage.setData({ + object: { foo: 'bar ' }, + array: [1, 2, 3, 4, 5], + string: 'hello', + boolean: true, + number: 123456, + }); + + // return json object so we can assert values + const mOutput = remoteMessage.toJSON(); + + mOutput.id.should.equal('foobar'); + mOutput.ttl.should.equal(12000); + mOutput.type.should.equal('something'); + mOutput.data.should.be.a.Object(); + + // all data types should be a string as this is all that native accepts + mOutput.data.object.should.equal('[object Object]'); + mOutput.data.array.should.equal('1,2,3,4,5'); + mOutput.data.string.should.equal('hello'); + mOutput.data.number.should.equal('123456'); + + return Promise.resolve(); + }); + + it('should send a RemoteMessage', () => { + const remoteMessage = new firebase.native.messaging.RemoteMessage('305229645282'); + + // all optional + remoteMessage.setId('foobar'); + remoteMessage.setTtl(12000); + remoteMessage.setType('something'); + remoteMessage.setData({ + object: { foo: 'bar ' }, + array: [1, 2, 3, 4, 5], + string: 'hello', + number: 123456, + }); + + firebase.native.messaging().send(remoteMessage); + return Promise.resolve(); + }); + + it('it should return fcm token from getToken', () => { + const successCb = (token) => { + console.log(token); + token.should.be.a.String(); + return Promise.resolve(); + }; + + return firebase.native.messaging() + .getToken() + .then(successCb); + }); + + it('it should build a RemoteMessage', () => { + const remoteMessage = new firebase.native.messaging.RemoteMessage('305229645282'); + + // all optional + remoteMessage.setId('foobar'); + remoteMessage.setTtl(12000); + remoteMessage.setType('something'); + remoteMessage.setData({ + object: { foo: 'bar ' }, + array: [1, 2, 3, 4, 5], + string: 'hello', + boolean: true, + number: 123456, + }); + + // return json object so we can assert values + const mOutput = remoteMessage.toJSON(); + + mOutput.id.should.equal('foobar'); + mOutput.ttl.should.equal(12000); + mOutput.type.should.equal('something'); + mOutput.data.should.be.a.Object(); + + // all data types should be a string as this is all that native accepts + mOutput.data.object.should.equal('[object Object]'); + mOutput.data.array.should.equal('1,2,3,4,5'); + mOutput.data.string.should.equal('hello'); + mOutput.data.number.should.equal('123456'); + + return Promise.resolve(); + }); + + + it('it should send a RemoteMessage', () => { + const remoteMessage = new firebase.native.messaging.RemoteMessage('305229645282'); + + // all optional + remoteMessage.setId('foobar'); + remoteMessage.setTtl(12000); + remoteMessage.setType('something'); + remoteMessage.setData({ + object: { foo: 'bar ' }, + array: [1, 2, 3, 4, 5], + string: 'hello', + number: 123456, + }); + + firebase.native.messaging().send(remoteMessage); + return Promise.resolve(); + }); + + it('it should create/remove onTokenRefresh listeners', () => { + const cb = () => { + }; + try { + const listener = firebase.native.messaging().onTokenRefresh(cb); + listener.remove(); + } catch (e) { + console.error(e); + } + + return Promise.resolve(); + }); + + it('it should subscribe/unsubscribe to topics', () => { + firebase.native.messaging().subscribeToTopic('foobar'); + firebase.native.messaging().unsubscribeFromTopic('foobar'); + return Promise.resolve(); + }); + + it('it should show a notification', () => { + firebase.native.messaging().createLocalNotification({ + title: 'Hello', + body: 'My Notification Message', + big_text: "Is it me you're looking for?", + sub_text: 'nope', + show_in_foreground: true, + }); + + return Promise.resolve(); + }); + }); +} + +export default messagingTests; diff --git a/tests/src/tests/storage/index.js b/tests/src/tests/storage/index.js new file mode 100644 index 00000000..62a745e7 --- /dev/null +++ b/tests/src/tests/storage/index.js @@ -0,0 +1,10 @@ +import firebase from '../../firebase'; +import TestSuite from '../../../lib/TestSuite'; +import storageTests from './storageTests'; + +const suite = new TestSuite('Storage', 'Upload/Download storage tests', firebase); + +suite.addTests(storageTests); + +export default suite; + diff --git a/tests/src/tests/storage/storageTests.js b/tests/src/tests/storage/storageTests.js new file mode 100644 index 00000000..104b27e9 --- /dev/null +++ b/tests/src/tests/storage/storageTests.js @@ -0,0 +1,90 @@ +function storageTests({ xdescribe, it, firebase, tryCatch }) { + xdescribe('downloadFile()', () => { + it('it should error on download file if permission denied', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch(() => { + reject(new Error('No permission denied error')); + }, reject); + + const failureCb = tryCatch((error) => { + error.code.should.equal('storage/unauthorized'); + error.message.includes('not authorized').should.be.true(); + resolve(); + }, reject); + + firebase.native.storage().ref('/not.jpg').downloadFile(`${firebase.native.storage.Native.DOCUMENT_DIRECTORY_PATH}/not.jpg`).then(successCb).catch(failureCb); + }); + }); + + it('it should download a file', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((meta) => { + meta.state.should.eql(firebase.native.storage.TaskState.SUCCESS); + meta.bytesTransferred.should.eql(meta.totalBytes); + resolve(); + }, reject); + + const failureCb = tryCatch((error) => { + reject(error); + }, reject); + + firebase.native.storage().ref('/ok.jpeg').downloadFile(`${firebase.native.storage.Native.DOCUMENT_DIRECTORY_PATH}/ok.jpeg`).then(successCb).catch(failureCb); + }); + }); + }); + + xdescribe('putFile()', () => { + it('it should error on upload if permission denied', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch(() => { + reject(new Error('No permission denied error')); + }, reject); + + const failureCb = tryCatch((error) => { + error.code.should.equal('storage/unauthorized'); + error.message.includes('not authorized').should.be.true(); + resolve(); + }, reject); + + firebase.native.storage().ref('/uploadNope.jpeg').putFile(`${firebase.native.storage.Native.DOCUMENT_DIRECTORY_PATH}/ok.jpeg`).then(successCb).catch(failureCb); + }); + }); + + it('it should upload a file', () => { + return new Promise((resolve, reject) => { + const successCb = tryCatch((uploadTaskSnapshot) => { + uploadTaskSnapshot.state.should.eql(firebase.native.storage.TaskState.SUCCESS); + uploadTaskSnapshot.bytesTransferred.should.eql(uploadTaskSnapshot.totalBytes); + uploadTaskSnapshot.metadata.should.be.an.Object(); + uploadTaskSnapshot.downloadUrl.should.be.a.String(); + resolve(); + }, reject); + + const failureCb = tryCatch((error) => { + reject(error); + }, reject); + + firebase.native.storage().ref('/uploadOk.jpeg').putFile(`${firebase.native.storage.Native.DOCUMENT_DIRECTORY_PATH}/ok.jpeg`).then(successCb).catch(failureCb); + }); + }); + }); + + xdescribe('on()', () => { + it('should listen to upload state', () => { + return new Promise((resolve, reject) => { + const path = `${firebase.native.storage.Native.DOCUMENT_DIRECTORY_PATH}/ok.jpeg`; + const ref = firebase.native.storage().ref('/uploadOk.jpeg'); + const unsubscribe = ref.putFile(path).on(firebase.native.storage.TaskEvent.STATE_CHANGED, tryCatch((snapshot) => { + if (snapshot.state === firebase.native.storage.TaskState.SUCCESS) { + resolve(); + } + }, reject), tryCatch((error) => { + unsubscribe(); + reject(error); + }, reject)); + }); + }); + }); +} + +export default storageTests; diff --git a/tests/src/tests/support/DatabaseContents.js b/tests/src/tests/support/DatabaseContents.js new file mode 100644 index 00000000..0f786cd5 --- /dev/null +++ b/tests/src/tests/support/DatabaseContents.js @@ -0,0 +1,25 @@ +export default { + DEFAULT: { + array: [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + ], + boolean: true, + string: 'foobar', + number: 123567890, + object: { + foo: 'bar', + }, + }, + + NEW: { + array: [ + 9, 8, 7, 6, 5, 4, + ], + boolean: false, + string: 'baz', + number: 84564564, + object: { + foo: 'baz', + }, + }, +}; diff --git a/tests/src/tests/support/databaseTypeMap.js b/tests/src/tests/support/databaseTypeMap.js new file mode 100644 index 00000000..8cbacf12 --- /dev/null +++ b/tests/src/tests/support/databaseTypeMap.js @@ -0,0 +1,10 @@ +import DatabaseContents from './DatabaseContents'; + +const databaseTypeMap = + Object.keys(DatabaseContents.DEFAULT).reduce((dataTypeMap, dataType) => { + // eslint-disable-next-line no-param-reassign + dataTypeMap[`tests/types/${dataType}`] = DatabaseContents.DEFAULT[dataType]; + return dataTypeMap; + }, {}); + +export default databaseTypeMap;

r9(T^(I1*f{28#Bt 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 ohyj3!`#ee%L;DTjx@8!5k5~VH0QmdE^#A|> literal 0 HcmV?d00001 diff --git a/tests/android/app/src/main/assets/fonts/Octicons.ttf b/tests/android/app/src/main/assets/fonts/Octicons.ttf new file mode 100644 index 0000000000000000000000000000000000000000..5b1f7d6ea2c870df4f29f4b40a300334844d2214 GIT binary patch literal 27428 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 literal 0 HcmV?d00001 diff --git a/tests/android/app/src/main/assets/fonts/SimpleLineIcons.ttf b/tests/android/app/src/main/assets/fonts/SimpleLineIcons.ttf new file mode 100644 index 0000000000000000000000000000000000000000..6ecb68683477ecc5aed38ec3fc8910d9bb66276c GIT binary patch literal 54056 zcmdqK2Y6iNwKlrH-S?ior|l`yj5L~}nNhD()HRYVx%b{=xqyu^#x`JZ2)1k>gceFd z4?!jgJq?l^l0!gnNc|H+l5;{%A&3-6I0-o?e+uDPTlZaiWaA|NJ-PR}&;6hKT*;c* zy?o#L)_T{w*80pbj^j*jf)luvqoZq=U3tp`;~e(`16!*W%pV!$>bb9T-1mQl_1KCv ztsUzpH-44l*hZ|c-*wTBgKq|28sj*j58HO`*>TCi*;!nP`~J_cU){6+==om{?fMqS z$+aB!0=M_P9lKqr*EV3^zu~X27aP=e;c1*3zAoKEzu-t{?;|F$Jbl#8N`amzoeFN9$m4g>wa_L=z4$Ot$4PD*i7$&pYj`EbzS+UXV%Mm%Wp7yn)?hl z>ulN1ZRcKdmX^={hMVRFXJ@#NVSRk|_xLLx^NG20>Fev<$n3jw+s|yCyEDhl+T7UL zedVWrfDXd8w(`NV_&IYLzIps^Kf6A+gd_0sIP1S?kMmi>o#Lj>9!K|aew^<%9KC{@ z#3$Y3W8Aq-_1-DvrCXi5m*zIF#P@c*m!DAl%E#1|np@kgeOddh{xjG6jNQhhDVkT9Z@725PkVmneZ;rV z_apy7|F^Au)*FG31>Ol3f=`56LZ1)s3_n}3wBnh{_f>vBvOe;1bZzvB=pU*MRQ;~{ zVC?+Zi?P!+Q}Md^_Y->)k0iz9;^gO3TxvY^quPOVDE&s}ShgyO)3x36sfMn^pNWWFkYcm9pS*233{ZN)pgjILjF zuk8MIPqODEPVgMpDgNH^yH#HEMB_!*(I?h zFD>m_cEhsYEnmO<%PZn5Zde&xdBZCAs;#SjvHHmB$<;5des@iB&5zektm|37e#1{T zmNw-!8(TJRd1>pd+e%~d*znksW53$|jq#=(kUR|QDUlPN=eoJ8IIfuu2*nmL+rscK z)t+=S#my^j=3y}*EV;#M7KrhkiH<@)%VjfCK35oI=>e86v?$pOehbAyae(1pXM0B| z917#CP*_%ETqPWciD4-mW8t7MWxwSb>d%XU67pFh^U1Ee_KjY)SP^xVS5h92nC~BQ z*>4GI$miC56{au|O?S(ukGoZgg}njBctI3pSr)?!!`@n*mn2ox4zFH)Sd(3h=NZ#$ zz1ZdQYK#{ZRmWKp-s1jiWK;JUg4x(S9CsaS+jYEq?@;Z+esAY_m6e81H|1-X;Pys5 z>&&oMOGVbTM)>GXlJ2@#iVdB730I59nP&X zS^lkWb~KM1>`5-{Ym0VtepmL#;vxR?p}4FWh9;OZf*W^2Ci$`*d5BWc15o1`cVBrL9a4bg==cUtI!d;BC#vGWr07$D~hJ;QZnS}D0Bp_ z%WPPmy{`S@>d<`O#eyLJ^k8sset+b;#7H4kY@oj9>o;VtYdusQOi@d#;>FmAAJ(me z{62T3XQex;KxIO!IYgG-2 z@d3}ccU@m^qI==G`jP9__V?Lu#%ow6!cWbVgvoKsgqj=2pJk3)5o_GEtf5NdS|#eO z4W(}`PI@z`c!kGZkw~R|lifGfDpt_tiz>~fY}+RnOx6r{HAm)MkeeKSwC!4dMQA*d zDNW!Ssz)2gpXprBx$v3s&I?oAFt?54I`dAWoYN%q=6}^B>}-o9-4ZoTXCj+!p{*X4 z%_Jec)PSLmBGf@4Q;M+4gc@zhS!jr2BzNIZTZ`s$TH(RWr}}!Jxn*af1lp)aprr$uy8-51na=+~VXp&9JPnikcy}cmDjn zwVl(P7}b-FG<#x(Jerit<|^$5v_qx%@zqQq^5Mb2YHo_$eA*Ev03 zZlYqLg`aCCba<@XOfuA2S#Yc(WFYCZh8(D2iVV>hWMRlhE-TcWePdpOMnkuc&rFu( zh4Hd3x8#N|>~xx`N`$ERs{;K!$2M#JsJ3OZ7Pa)vn{_LyZQi0q{Tg4I%v~_g>Fr0_ zuSE;GgF3zEoV=($Xd)7s#FAX+5~r0ywGb6G=V|?k&)CvK7(a8!M!v zR-r9AVx*89K?sGVwitRH+MWi`nMNr7RZ}@up@nZHi%?chJeOTFP*)xUQk;dMw4pvv zpTN7vwW^lR;eENe(cq|hD3ggu+O+(NZ2z*aw{zvbPGO>^wY&06XV-eJfkKy5Lm6O> zP%LnU2i~E@y7!l401CLYGU1;ZW)!O?q-tWXSxIx+M!t!EYocr2rF z=Jcau-pKmL_zu`3evmm^s6}xJT63DUm&pJT5IIJJioS6IE(~~qfhi0CanOySgymqs zIW^DkefcZbuR4Cn6>-b1Rr#b#F(a;|KP0566;pCHu4sNuQC#u%1%Ay^RY?_?=+CTb zu%iAA%l!;cfee=bZ6oq9@Cxr+&=!*wkryP7Dym{EBd4fIQ*v$Gs8n#EBF77BU9tjo zB5CU36RWQ8hUHW$jZb^Lk&G|qi)4h4uDbr&z1O_40MigonFb#f*qNHTsUQN*J`*kv)+KI#{A!<1B&=Y7jI;2P_e z`W3~HOhXr}l{ws7R77d?&Fl6&d%gVy$>UXBihQ1yiQs865l)0>vI6*{ovY@0xuw7$ z9HcxIhjEh?LTHJ2kzk)7kmNeh52mm}hY@i?-7Q7WXpy^%n$Qb9=P<);D6&+hIJh^T%NB4sf(blM$?#9CEDjWcy~PfrI^kzEy;}}_c=bIeTtQ=Eci)&_ zb{TSIcyMjDsj@a`8Y5plB<*M8_OG_xWSrV##iWEU>G2Lj2tqku$`|k{!GxlCtXrSh z_sk9FD*%q8V#y=L?B0qo$OUL;ggyX}Ef?IJ|Rl!%D_4VTBcHWtT-VnkNtlxfNfvU-MU(Lq09iR9M;CpI1ieyn&S46ZEwVM|HHs z15qH?NwPQ7m6RN>x%dQ+qYBp##@%Ql+w{yd%VI_d0(|}r&;0G z?H?{~tY~Pe2^hTBQse$R>in{iGDIU?@xx4HJer=2rs2NN&b}>Z?q~I*tKb(ePbz-$wctHfCEcH5CSa|--&JM$ZAnI$i{g|mK6yw?Cx