diff --git a/packages/firebase_database/CHANGELOG.md b/packages/firebase_database/CHANGELOG.md index 38867a464897..7b8caa2fb300 100644 --- a/packages/firebase_database/CHANGELOG.md +++ b/packages/firebase_database/CHANGELOG.md @@ -1,3 +1,10 @@ +## 0.0.8 + +* Added missing offline persistence and query functionality on Android +* Fixed startAt query behavior on iOS +* Persistence methods no longer throw errors on failure, return false instead +* Updates to docs and tests + ## 0.0.7 * Fixed offline persistence on iOS diff --git a/packages/firebase_database/android/src/main/java/io/flutter/plugins/firebase/database/FirebaseDatabasePlugin.java b/packages/firebase_database/android/src/main/java/io/flutter/plugins/firebase/database/FirebaseDatabasePlugin.java index 51f000c3f505..e7ff45988b24 100644 --- a/packages/firebase_database/android/src/main/java/io/flutter/plugins/firebase/database/FirebaseDatabasePlugin.java +++ b/packages/firebase_database/android/src/main/java/io/flutter/plugins/firebase/database/FirebaseDatabasePlugin.java @@ -8,8 +8,10 @@ import com.google.firebase.database.ChildEventListener; import com.google.firebase.database.DataSnapshot; import com.google.firebase.database.DatabaseError; +import com.google.firebase.database.DatabaseException; import com.google.firebase.database.DatabaseReference; import com.google.firebase.database.FirebaseDatabase; +import com.google.firebase.database.Query; import com.google.firebase.database.ValueEventListener; import io.flutter.plugin.common.MethodCall; import io.flutter.plugin.common.MethodChannel; @@ -31,7 +33,7 @@ public class FirebaseDatabasePlugin implements MethodCallHandler { // Handles are ints used as indexes into the sparse array of active observers private int nextHandle = 0; - private final SparseArray observers = new SparseArray(); + private final SparseArray observers = new SparseArray<>(); public static void registerWith(PluginRegistry.Registrar registrar) { final MethodChannel channel = @@ -43,14 +45,75 @@ private FirebaseDatabasePlugin(MethodChannel channel) { this.channel = channel; } - private static DatabaseReference getReference(Map arguments) { - @SuppressWarnings("unchecked") + private DatabaseReference getReference(Map arguments) { String path = (String) arguments.get("path"); DatabaseReference reference = FirebaseDatabase.getInstance().getReference(); if (path != null) reference = reference.child(path); return reference; } + private Query getQuery(Map arguments) { + Query query = getReference(arguments); + @SuppressWarnings("unchecked") + Map parameters = (Map) arguments.get("parameters"); + if (parameters == null) return query; + Object orderBy = parameters.get("orderBy"); + if ("child".equals(orderBy)) { + query = query.orderByChild((String) parameters.get("orderByChildKey")); + } else if ("key".equals(orderBy)) { + query = query.orderByKey(); + } else if ("value".equals(orderBy)) { + query = query.orderByValue(); + } else if ("priority".equals(orderBy)) { + query = query.orderByPriority(); + } + if (parameters.containsKey("startAt")) { + Object startAt = parameters.get("startAt"); + String startAtKey = (String) parameters.get("startAtKey"); + if (startAt instanceof Boolean) { + query = query.startAt((Boolean) startAt, startAtKey); + } else if (startAt instanceof String) { + query = query.startAt((String) startAt, startAtKey); + } else if (startAt instanceof Double) { + query = query.endAt((Double) startAt); + } else if (startAt instanceof Integer) { + query = query.startAt((int) startAt); + } + } + if (parameters.containsKey("endAt")) { + Object endAt = parameters.get("endAt"); + String endAtKey = (String) parameters.get("endAtKey"); + if (endAt instanceof Boolean) { + query = query.endAt((Boolean) endAt, endAtKey); + } else if (endAt instanceof String) { + query = query.endAt((String) endAt, endAtKey); + } else if (endAt instanceof Double) { + query = query.endAt((Double) endAt); + } else if (endAt instanceof Integer) { + query = query.endAt((int) endAt); + } + } + if (parameters.containsKey("equalTo")) { + Object equalTo = parameters.get("equalTo"); + if (equalTo instanceof Boolean) { + query = query.equalTo((Boolean) equalTo); + } else if (equalTo instanceof String) { + query = query.equalTo((String) equalTo); + } else if (equalTo instanceof Double) { + query = query.equalTo((Double) equalTo); + } else if (equalTo instanceof Integer) { + query = query.equalTo((int) equalTo); + } + } + if (parameters.containsKey("limitToFirst")) { + query = query.limitToFirst((int) parameters.get("limitToFirst")); + } + if (parameters.containsKey("limitToLast")) { + query = query.limitToLast((int) parameters.get("limitToLast")); + } + return query; + } + private class DefaultCompletionListener implements DatabaseReference.CompletionListener { private final Result result; @@ -79,8 +142,8 @@ private class EventObserver implements ChildEventListener, ValueEventListener { private void sendEvent(String eventType, DataSnapshot snapshot, String previousChildName) { if (eventType.equals(requestedEventType)) { - Map arguments = new HashMap(); - Map snapshotMap = new HashMap(); + Map arguments = new HashMap<>(); + Map snapshotMap = new HashMap<>(); snapshotMap.put("key", snapshot.getKey()); snapshotMap.put("value", snapshot.getValue()); arguments.put("handle", handle); @@ -119,39 +182,59 @@ public void onDataChange(DataSnapshot snapshot) { } } - @SuppressWarnings("unchecked") @Override public void onMethodCall(MethodCall call, final Result result) { - Map arguments = (Map) call.arguments; switch (call.method) { case "FirebaseDatabase#goOnline": - FirebaseDatabase.getInstance().goOnline(); - break; + { + FirebaseDatabase.getInstance().goOnline(); + result.success(null); + break; + } case "FirebaseDatabase#goOffline": - FirebaseDatabase.getInstance().goOffline(); - break; + { + FirebaseDatabase.getInstance().goOffline(); + result.success(null); + break; + } case "FirebaseDatabase#purgeOutstandingWrites": - FirebaseDatabase.getInstance().purgeOutstandingWrites(); - break; + { + FirebaseDatabase.getInstance().purgeOutstandingWrites(); + result.success(null); + break; + } case "FirebaseDatabase#setPersistenceEnabled": { - boolean isEnabled = (boolean) arguments.get("enabled"); - FirebaseDatabase.getInstance().setPersistenceEnabled(isEnabled); + Boolean isEnabled = (Boolean) call.arguments; + try { + FirebaseDatabase.getInstance().setPersistenceEnabled(isEnabled); + result.success(true); + } catch (DatabaseException e) { + // Database is already in use, e.g. after hot reload/restart. + result.success(false); + } break; } case "FirebaseDatabase#setPersistenceCacheSizeBytes": { - long cacheSize = (long) arguments.get("cacheSize"); - FirebaseDatabase.getInstance().setPersistenceCacheSizeBytes(cacheSize); + long cacheSize = (Integer) call.arguments; + try { + FirebaseDatabase.getInstance().setPersistenceCacheSizeBytes(cacheSize); + result.success(true); + } catch (DatabaseException e) { + // Database is already in use, e.g. after hot reload/restart. + result.success(false); + } break; } case "DatabaseReference#set": { + Map arguments = call.arguments(); Object value = arguments.get("value"); Object priority = arguments.get("priority"); DatabaseReference reference = getReference(arguments); @@ -165,22 +248,32 @@ public void onMethodCall(MethodCall call, final Result result) { case "DatabaseReference#setPriority": { + Map arguments = call.arguments(); Object priority = arguments.get("priority"); DatabaseReference reference = getReference(arguments); reference.setPriority(priority, new DefaultCompletionListener(result)); break; } + case "Query#keepSynced": + { + Map arguments = call.arguments(); + boolean value = (Boolean) arguments.get("value"); + getQuery(arguments).keepSynced(value); + break; + } + case "Query#observe": { + Map arguments = call.arguments(); String eventType = (String) arguments.get("eventType"); int handle = nextHandle++; EventObserver observer = new EventObserver(eventType, handle); observers.put(handle, observer); if (eventType.equals(EVENT_TYPE_VALUE)) { - getReference(arguments).addValueEventListener(observer); + getQuery(arguments).addValueEventListener(observer); } else { - getReference(arguments).addChildEventListener(observer); + getQuery(arguments).addChildEventListener(observer); } result.success(handle); break; @@ -188,14 +281,15 @@ public void onMethodCall(MethodCall call, final Result result) { case "Query#removeObserver": { - DatabaseReference reference = getReference(arguments); + Map arguments = call.arguments(); + Query query = getQuery(arguments); int handle = (Integer) arguments.get("handle"); EventObserver observer = observers.get(handle); if (observer != null) { if (observer.requestedEventType.equals(EVENT_TYPE_VALUE)) { - reference.removeEventListener((ValueEventListener) observer); + query.removeEventListener((ValueEventListener) observer); } else { - reference.removeEventListener((ChildEventListener) observer); + query.removeEventListener((ChildEventListener) observer); } observers.delete(handle); result.success(null); diff --git a/packages/firebase_database/example/lib/main.dart b/packages/firebase_database/example/lib/main.dart index 66185a88eeb9..74e14af52d63 100755 --- a/packages/firebase_database/example/lib/main.dart +++ b/packages/firebase_database/example/lib/main.dart @@ -44,12 +44,16 @@ class _MyHomePageState extends State { @override void initState() { super.initState(); + FirebaseDatabase.instance.setPersistenceEnabled(true); + FirebaseDatabase.instance.setPersistenceCacheSizeBytes(10000000); + _counterRef.keepSynced(true); _counterSubscription = _counterRef.onValue.listen((Event event) { setState(() { _counter = event.snapshot.value ?? 0; }); }); - _messagesSubscription = _messagesRef.onChildAdded.listen((Event event) { + _messagesSubscription = + _messagesRef.limitToLast(10).onChildAdded.listen((Event event) { print('Child added: ${event.snapshot.value}'); }); } diff --git a/packages/firebase_database/ios/Classes/FirebaseDatabasePlugin.m b/packages/firebase_database/ios/Classes/FirebaseDatabasePlugin.m index 582d8905809e..4e40b8c93bab 100644 --- a/packages/firebase_database/ios/Classes/FirebaseDatabasePlugin.m +++ b/packages/firebase_database/ios/Classes/FirebaseDatabasePlugin.m @@ -40,7 +40,7 @@ - (FlutterError *)flutterError { } id startAt = parameters[@"startAt"]; if (startAt) { - query = [query queryStartingAtValue:startAt childKey:parameters[@"endAtKey"]]; + query = [query queryStartingAtValue:startAt childKey:parameters[@"startAtKey"]]; } id endAt = parameters[@"endAt"]; if (endAt) { @@ -109,16 +109,39 @@ - (void)handleMethodCall:(FlutterMethodCall *)call result:(FlutterResult)result }; if ([@"FirebaseDatabase#goOnline" isEqualToString:call.method]) { [[FIRDatabase database] goOnline]; + result(nil); } else if ([@"FirebaseDatabase#goOffline" isEqualToString:call.method]) { [[FIRDatabase database] goOffline]; + result(nil); } else if ([@"FirebaseDatabase#purgeOutstandingWrites" isEqualToString:call.method]) { [[FIRDatabase database] purgeOutstandingWrites]; + result(nil); } else if ([@"FirebaseDatabase#setPersistenceEnabled" isEqualToString:call.method]) { - NSNumber *value = call.arguments[@"enabled"]; - [FIRDatabase database].persistenceEnabled = value.boolValue; + NSNumber *value = call.arguments; + @try { + [FIRDatabase database].persistenceEnabled = value.boolValue; + result([NSNumber numberWithBool:YES]); + } @catch (NSException *exception) { + if ([@"FIRDatabaseAlreadyInUse" isEqualToString:exception.name]) { + // Database is already in use, e.g. after hot reload/restart. + result([NSNumber numberWithBool:NO]); + } else { + @throw; + } + } } else if ([@"FirebaseDatabase#setPersistenceCacheSizeBytes" isEqualToString:call.method]) { - NSNumber *value = call.arguments[@"cacheSize"]; - [FIRDatabase database].persistenceCacheSizeBytes = value.unsignedIntegerValue; + NSNumber *value = call.arguments; + @try { + [FIRDatabase database].persistenceCacheSizeBytes = value.unsignedIntegerValue; + result([NSNumber numberWithBool:YES]); + } @catch (NSException *exception) { + if ([@"FIRDatabaseAlreadyInUse" isEqualToString:exception.name]) { + // Database is already in use, e.g. after hot reload/restart. + result([NSNumber numberWithBool:NO]); + } else { + @throw; + } + } } else if ([@"DatabaseReference#set" isEqualToString:call.method]) { [getReference(call.arguments) setValue:call.arguments[@"value"] andPriority:call.arguments[@"priority"] diff --git a/packages/firebase_database/lib/src/database_reference.dart b/packages/firebase_database/lib/src/database_reference.dart index 75ed7a807a2a..2a3ece39117c 100644 --- a/packages/firebase_database/lib/src/database_reference.dart +++ b/packages/firebase_database/lib/src/database_reference.dart @@ -97,10 +97,10 @@ class DatabaseReference extends Query { /// priority (including no priority), they are sorted by key. Numeric keys /// come first (sorted numerically), followed by the remaining keys (sorted /// lexicographically). - + /// /// Note that priorities are parsed and ordered as IEEE 754 double-precision /// floating-point numbers. Keys are always stored as strings and are treated - /// as numbers only when they can be parsed as a 32-bit integer + /// as numbers only when they can be parsed as a 32-bit integer. Future setPriority(dynamic priority) async { return _database._channel.invokeMethod( 'DatabaseReference#setPriority', diff --git a/packages/firebase_database/lib/src/firebase_database.dart b/packages/firebase_database/lib/src/firebase_database.dart index d2ce9307b6a2..678f0dd59227 100644 --- a/packages/firebase_database/lib/src/firebase_database.dart +++ b/packages/firebase_database/lib/src/firebase_database.dart @@ -32,52 +32,65 @@ class FirebaseDatabase { /// Gets a DatabaseReference for the root of your Firebase Database. DatabaseReference reference() => new DatabaseReference._(this, []); + /// Attempts to sets the database persistence to [enabled]. + /// + /// This property must be set before calling methods on database references + /// and only needs to be called once per application. The returned [Future] + /// will complete with `true` if the operation was successful or `false` if + /// the persistence could not be set (because database references have + /// already been created). + /// /// The Firebase Database client will cache synchronized data and keep track /// of all writes you’ve initiated while your application is running. It /// seamlessly handles intermittent network connections and re-sends write /// operations when the network connection is restored. /// /// However by default your write operations and cached data are only stored - /// in-memory and will be lost when your app restarts. By setting this value - /// to YES, the data will be persisted to on-device (disk) storage and will + /// in-memory and will be lost when your app restarts. By setting [enabled] + /// to `true`, the data will be persisted to on-device (disk) storage and will /// thus be available again when the app is restarted (even when there is no - /// network connectivity at that time). Note that this property must be set - /// before creating your first Database reference and only needs to be called - /// once per application. - Future setPersistenceEnabled(bool enabled) { + /// network connectivity at that time). + Future setPersistenceEnabled(bool enabled) { return _channel.invokeMethod( - "FirebaseDatabase#setPersistenceEnabled", - {'enabled': enabled}, + 'FirebaseDatabase#setPersistenceEnabled', + enabled, ); } + /// Attempts to set the size of the persistence cache. + /// /// By default the Firebase Database client will use up to 10MB of disk space /// to cache data. If the cache grows beyond this size, the client will start /// removing data that hasn’t been recently used. If you find that your /// application caches too little or too much data, call this method to change - /// the cache size. This property must be set before creating your first - /// FIRDatabaseReference and only needs to be called once per application. + /// the cache size. + /// + /// This property must be set before calling methods on database references + /// and only needs to be called once per application. The returned [Future] + /// will complete with `true` if the operation was successful or `false` if + /// the value could not be set (because database references have already been + /// created). /// /// Note that the specified cache size is only an approximation and the size /// on disk may temporarily exceed it at times. Cache sizes smaller than 1 MB /// or greater than 100 MB are not supported. - Future setPersistenceCacheSizeBytes(int cacheSize) { + Future setPersistenceCacheSizeBytes(int cacheSize) { return _channel.invokeMethod( - "FirebaseDatabase#setPersistenceCacheSizeBytes", - {'cacheSize': cacheSize}, + 'FirebaseDatabase#setPersistenceCacheSizeBytes', + cacheSize, ); } /// Resumes our connection to the Firebase Database backend after a previous - /// goOffline call. + /// [goOffline] call. Future goOnline() { - return _channel.invokeMethod("FirebaseDatabase#goOnline"); + return _channel.invokeMethod('FirebaseDatabase#goOnline'); } - /// Shuts down our connection to the Firebase Database backend until goOnline - /// is called. + /// Shuts down our connection to the Firebase Database backend until + /// [goOnline] is called. Future goOffline() { - return _channel.invokeMethod("FirebaseDatabase#goOffline"); + return _channel.invokeMethod('FirebaseDatabase#goOffline'); } /// The Firebase Database client automatically queues writes and sends them to @@ -91,6 +104,6 @@ class FirebaseDatabase { /// affected event listeners, and the client will not (re-)send them to the /// Firebase Database backend. Future purgeOutstandingWrites() { - return _channel.invokeMethod("FirebaseDatabase#purgeOutstandingWrites"); + return _channel.invokeMethod('FirebaseDatabase#purgeOutstandingWrites'); } } diff --git a/packages/firebase_database/lib/src/query.dart b/packages/firebase_database/lib/src/query.dart index 94eb0d28149b..9ee9284b98b1 100644 --- a/packages/firebase_database/lib/src/query.dart +++ b/packages/firebase_database/lib/src/query.dart @@ -93,7 +93,10 @@ class Query { /// than or equal to the given key. Query startAt(dynamic value, { String key }) { assert(!_parameters.containsKey('startAt')); - return _copyWithParameters({ 'startAt': value, 'startAtKey': key}); + assert(value is String || value is bool || value is double || value is int); + return _copyWithParameters( + { 'startAt': value, 'startAtKey': key }, + ); } /// Create a query constrained to only return child nodes with a value less @@ -102,7 +105,10 @@ class Query { /// than or equal to the given key. Query endAt(dynamic value, { String key }) { assert(!_parameters.containsKey('endAt')); - return _copyWithParameters({ 'endAt': value, 'endAtKey': key}); + assert(value is String || value is bool || value is double || value is int); + return _copyWithParameters( + { 'endAt': value, 'endAtKey': key }, + ); } /// Create a query constrained to only return child nodes with the given @@ -111,7 +117,10 @@ class Query { /// If a key is provided, there is at most one such child as names are unique. Query equalTo(dynamic value, { String key }) { assert(!_parameters.containsKey('equalTo')); - return _copyWithParameters({ 'equalTo': value, 'equalToKey': key }); + assert(value is String || value is bool || value is double || value is int); + return _copyWithParameters( + { 'equalTo': value, 'equalToKey': key }, + ); } /// Create a query with limit and anchor it to the start of the window. @@ -128,16 +137,20 @@ class Query { /// Generate a view of the data sorted by values of a particular child key. /// - /// Intended to be used in combination with startAt(), endAt(), or equalTo(). + /// Intended to be used in combination with [startAt], [endAt], or + /// [equalTo]. Query orderByChild(String key) { assert(key != null); assert(!_parameters.containsKey('orderBy')); - return _copyWithParameters({ 'orderBy': 'child', 'orderByChildKey': key }); + return _copyWithParameters( + { 'orderBy': 'child', 'orderByChildKey': key }, + ); } /// Generate a view of the data sorted by key. /// - /// Intended to be used in combination with startAt(), endAt(), or equalTo(). + /// Intended to be used in combination with [startAt], [endAt], or + /// [equalTo]. Query orderByKey() { assert(!_parameters.containsKey('orderBy')); return _copyWithParameters({ 'orderBy': 'key' }); @@ -145,7 +158,8 @@ class Query { /// Generate a view of the data sorted by value. /// - /// Intended to be used in combination with startAt(), endAt(), or equalTo(). + /// Intended to be used in combination with [startAt], [endAt], or + /// [equalTo]. Query orderByValue() { assert(!_parameters.containsKey('orderBy')); return _copyWithParameters({ 'orderBy': 'value' }); @@ -153,7 +167,8 @@ class Query { /// Generate a view of the data sorted by priority. /// - /// Intended to be used in combination with startAt(), endAt(), or equalTo(). + /// Intended to be used in combination with [startAt], [endAt], or + /// [equalTo]. Query orderByPriority() { assert(!_parameters.containsKey('orderBy')); return _copyWithParameters({ 'orderBy': 'priority' }); diff --git a/packages/firebase_database/pubspec.yaml b/packages/firebase_database/pubspec.yaml index 593f34becdf9..dad3c9aafc47 100755 --- a/packages/firebase_database/pubspec.yaml +++ b/packages/firebase_database/pubspec.yaml @@ -3,7 +3,7 @@ name: firebase_database description: Firebase Database plugin for Flutter. author: Flutter Team homepage: https://github.com/flutter/plugins/tree/master/packages/firebase_database -version: 0.0.7 +version: 0.0.8 flutter: plugin: @@ -16,7 +16,6 @@ dependencies: meta: "^1.0.5" dev_dependencies: - mockito: ^2.0.2 test: 0.12.21 environment: diff --git a/packages/firebase_database/test/firebase_database_test.dart b/packages/firebase_database/test/firebase_database_test.dart index 6a5d5a7856fb..f4397b353942 100755 --- a/packages/firebase_database/test/firebase_database_test.dart +++ b/packages/firebase_database/test/firebase_database_test.dart @@ -4,7 +4,6 @@ import 'dart:async'; -import 'package:mockito/mockito.dart'; import 'package:test/test.dart'; import 'package:flutter/services.dart'; @@ -24,64 +23,70 @@ void main() { setUp(() async { channel.setMockMethodCallHandler((MethodCall methodCall) async { log.add(methodCall); - if (methodCall.method == 'Query#observe') { - return mockHandleId++; + switch (methodCall.method) { + case 'Query#observe': + return mockHandleId++; + case 'FirebaseDatabase#setPersistenceEnabled': + return true; + case 'FirebaseDatabase#setPersistenceCacheSizeBytes': + return true; + default: + return null; } - return null; }); log.clear(); }); test('setPersistenceEnabled', () async { - await database.setPersistenceEnabled(false); - await database.setPersistenceEnabled(true); + expect(await database.setPersistenceEnabled(false), true); + expect(await database.setPersistenceEnabled(true), true); expect( - log, - equals([ - new MethodCall('FirebaseDatabase#setPersistenceEnabled', - {'enabled': false}), - new MethodCall('FirebaseDatabase#setPersistenceEnabled', - {'enabled': true}), - ])); + log, + equals([ + const MethodCall('FirebaseDatabase#setPersistenceEnabled', false), + const MethodCall('FirebaseDatabase#setPersistenceEnabled', true), + ]), + ); }); test('setPersistentCacheSizeBytes', () async { - await database.setPersistenceCacheSizeBytes(42); + expect(await database.setPersistenceCacheSizeBytes(42), true); expect( - log, - equals([ - new MethodCall( - 'FirebaseDatabase#setPersistenceCacheSizeBytes', - {'cacheSize': 42}, - ), - ])); + log, + equals([ + const MethodCall('FirebaseDatabase#setPersistenceCacheSizeBytes', 42), + ]), + ); }); test('goOnline', () async { await database.goOnline(); expect( - log, - equals([ - const MethodCall('FirebaseDatabase#goOnline'), - ])); + log, + equals([ + const MethodCall('FirebaseDatabase#goOnline'), + ]), + ); }); test('goOffline', () async { await database.goOffline(); expect( - log, - equals([ - const MethodCall('FirebaseDatabase#goOffline'), - ])); + log, + equals([ + const MethodCall('FirebaseDatabase#goOffline'), + ]), + ); }); test('purgeOutstandingWrites', () async { await database.purgeOutstandingWrites(); expect( - log, - equals([ - const MethodCall('FirebaseDatabase#purgeOutstandingWrites'), - ])); + log, + equals([ + const MethodCall('FirebaseDatabase#purgeOutstandingWrites'), + ]), + ); }); group('$DatabaseReference', () { @@ -91,25 +96,26 @@ void main() { await database.reference().child('foo').set(value); await database.reference().child('bar').set(value, priority: priority); expect( - log, - equals([ - new MethodCall( - 'DatabaseReference#set', - { - 'path': 'foo', - 'value': value, - 'priority': null - }, - ), - new MethodCall( - 'DatabaseReference#set', - { - 'path': 'bar', - 'value': value, - 'priority': priority - }, - ), - ])); + log, + equals([ + new MethodCall( + 'DatabaseReference#set', + { + 'path': 'foo', + 'value': value, + 'priority': null + }, + ), + new MethodCall( + 'DatabaseReference#set', + { + 'path': 'bar', + 'value': value, + 'priority': priority + }, + ), + ]), + ); }); test('setPriority', () async { @@ -163,5 +169,3 @@ void main() { }); }); } - -class MockPlatformChannel extends Mock implements MethodChannel {}