[observe] provide notifications of keys/values changed for ObservableMap

pkg/observe/test/observable_map_test.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 import 'package:observe/observe.dart';
 import 'package:unittest/unittest.dart';
 import 'observe_test_utils.dart';
 
 main() => dirtyCheckZone().run(_runTests);
@@ skipping 170 matching lines @@
             [_removeKey('b', 2), _insertKey('b', 2)]);
       });
     });
   });
 
   test('toString', () {
     var map = toObservable({'a': 1, 'b': 2});
     expect(map.toString(), '{a: 1, b: 2}');
   });
 
+  group('observe keys/values', () {
+    ObservableMap map;
+    int keysChanged;
+    int valuesChanged;
+
+    setUp(() {
+      map = toObservable({'a': 1, 'b': 2, 'c': 3});
+      keysChanged = 0;
+      valuesChanged = 0;
+      sub = map.changes.listen((records) {
+        keysChanged += getPropertyChangeRecords(records, #keys).length;
+        valuesChanged += getPropertyChangeRecords(records, #values).length;
+      });
+    });
+
+    tearDown(sharedTearDown);
+
+    test('add item changes keys/values', () {
+      map['d'] = 4;
+      expect(map, {'a': 1, 'b': 2, 'c': 3, 'd': 4});
+      return new Future(() {
+        expect(keysChanged, 1);
+        expect(valuesChanged, 1);
+      });
+    });
+
+    test('putIfAbsent changes keys/values', () {
+      map.putIfAbsent('d', () => 4);
+      expect(map, {'a': 1, 'b': 2, 'c': 3, 'd': 4});
+      return new Future(() {
+        expect(keysChanged, 1);
+        expect(valuesChanged, 1);
+      });
+    });
+
+    test('remove changes keys/values', () {
+      map.remove('c');
+      map.remove('a');
+      expect(map, {'b': 2});
+      return new Future(() {
+        expect(keysChanged, 2);
+        expect(valuesChanged, 2);
+      });
+    });
+
+    test('remove non-existent item does not change keys/values', () {
+      map.remove('d');
+      expect(map, {'a': 1, 'b': 2, 'c': 3});
+      return new Future(() {
+        expect(keysChanged, 0);
+        expect(valuesChanged, 0);
+      });
+    });
+
+    test('set existing item does not change keys', () {
+      map['c'] = 9000;
+      expect(map, {'a': 1, 'b': 2, 'c': 9000});
+      return new Future(() {
+        expect(keysChanged, 0);
+        expect(valuesChanged, 1);
+      });
+    });
+
+    test('clear changes keys/values', () {
+      map.clear();
+      expect(map, {});
+      return new Future(() {
+        expect(keysChanged, 1);
+        expect(valuesChanged, 1);
+      });
+    });
+  });
+
+
   group('change records', () {
     List<ChangeRecord> records;
     ObservableMap map;
 
     setUp(() {
       map = toObservable({'a': 1, 'b': 2});
       records = null;
       map.changes.first.then((r) { records = r; });
     });
 
@@ skipping 24 matching lines @@
       map.putIfAbsent('a', () => 42);
       expect(map, {'a': 1, 'b': 2});
 
       map.putIfAbsent('c', () => 3);
       expect(map, {'a': 1, 'b': 2, 'c': 3});
 
       return new Future(() {
         expectChanges(records, [
           _lengthChange(map, 2, 3),
           _insertKey('c', 3),
+          _propChange(map, #keys),
+          _propChange(map, #values),
         ]);
       });
     });
 
     test('[]=', () {
       map['a'] = 42;
       expect(map, {'a': 42, 'b': 2});
 
       map['c'] = 3;
       expect(map, {'a': 42, 'b': 2, 'c': 3});
 
       return new Future(() {
         expectChanges(records, [
           _changeKey('a', 1, 42),
+          _propChange(map, #values),
           _lengthChange(map, 2, 3),
-          _insertKey('c', 3)
+          _insertKey('c', 3),
+          _propChange(map, #keys),
+          _propChange(map, #values),
         ]);
       });
     });
 
     test('remove', () {
       map.remove('b');
       expect(map, {'a': 1});
 
       return new Future(() {
         expectChanges(records, [
           _removeKey('b', 2),
           _lengthChange(map, 2, 1),
+          _propChange(map, #keys),
+          _propChange(map, #values),
         ]);
       });
     });
 
     test('clear', () {
       map.clear();
       expect(map, {});
 
       return new Future(() {
         expectChanges(records, [
           _removeKey('a', 1),
           _removeKey('b', 2),
           _lengthChange(map, 2, 0),
+          _propChange(map, #keys),
+          _propChange(map, #values),
         ]);
       });
     });
   });
 }
 
 _lengthChange(map, int oldValue, int newValue) =>
     new PropertyChangeRecord(map, #length, oldValue, newValue);
 
 _changeKey(key, old, newValue) => new MapChangeRecord(key, old, newValue);
 
 _insertKey(key, newValue) => new MapChangeRecord.insert(key, newValue);
 
 _removeKey(key, oldValue) => new MapChangeRecord.remove(key, oldValue);
+
+_propChange(map, prop) => new PropertyChangeRecord(map, prop, null, null);