Some fixes to work better with the services framework

pkg/serialization/test/serialization_test.dart

 // Copyright (c) 2012, 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.
 
 library serialization_test;
 
 import 'dart:json' as json;
 import 'package:unittest/unittest.dart';
 import 'package:serialization/serialization.dart';
 import 'package:serialization/src/serialization_helpers.dart';
 import 'package:serialization/src/mirrors_helpers.dart';
 
 part 'test_models.dart';
 
 main() {
   var p1 = new Person();
   var a1 = new Address();
   a1.street = 'N 34th';
   a1.city = 'Seattle';
 
+  var formats = [new SimpleFlatFormat(), new SimpleMapFormat(),
+                 new SimpleJsonFormat(storeRoundTripInfo: true)];
+
   test('Basic extraction of a simple object', () {
     // TODO(alanknight): Switch these to use literal types. Issue
     var s = new Serialization()
         ..addRuleFor(a1).configureForMaps();
     Map extracted = states(a1, s).first;
     expect(extracted.length, 4);
     expect(extracted['street'], 'N 34th');
     expect(extracted['city'], 'Seattle');
     expect(extracted['state'], null);
     expect(extracted['zip'], null);
     Reader reader = setUpReader(s, extracted);
     Address a2 = readBackSimple(s, a1, reader);
     expect(a2.street, 'N 34th');
     expect(a2.city, 'Seattle');
     expect(a2.state,null);
     expect(a2.zip, null);
   });
 
   test('Slightly further with a simple object', () {
-    // TODO(alanknight): Tests that rely on what index rules are going to be
-    // at are very fragile. At least abstract it to something calculated.
     var p1 = new Person()..name = 'Alice'..address = a1;
     var s = new Serialization()
         ..addRuleFor(p1).configureForMaps()
         ..addRuleFor(a1).configureForMaps();
     // TODO(alanknight): Need a better API for getting to flat state without
     // actually writing.
     var w = new Writer(s);
     w.write(p1);
     var personRule = s.rules.firstMatching(
         (x) => x is BasicRule && x.type == reflect(p1).type);
@@ skipping 200 matching lines @@
   });
 
   test('round-trip with Node CustomRule, to maps', () {
     runRoundTripTest(nodeSerializerCustom);
   });
 
   test('eating your own tail', () {
     // Create a meta-serializer, that serializes serializations, then
     // use it to serialize a basic serialization, then run a test on the
     // the result.
-    var s = new Serialization()
+    var s = new Serialization.blank()
+      // Add the rules in a deliberately unusual order.
       ..addRuleFor(new Node(''), constructorFields: ['name'])
+      ..addRule(new ListRule())
+      ..addRule(new PrimitiveRule())
       ..selfDescribing = false;
     var meta = metaSerialization();
-    var serialized = meta.write(s);
-    var s2 = new Reader(meta)
-        .read(serialized, {"Node" : reflect(new Node('')).type});
-    runRoundTripTest((x) => s2);
+    var metaWithMaps = metaSerializationUsingMaps();
+    for (var eachFormat in formats) {
+      for (var eachMeta in [meta, metaWithMaps]) {
+        var serialized = eachMeta.write(s, eachFormat);
+        var reader = new Reader(eachMeta, eachFormat);
+        var newSerialization = reader.read(serialized,
+           {"serialization_test.Node" : reflect(new Node('')).type});
+        runRoundTripTest((x) => newSerialization);
+      }
+    }
   });
 
   test("Verify we're not serializing lists twice if they're essential", () {
     Node n1 = new Node("1"), n2 = new Node("2"), n3 = new Node("3");
     n1.children = [n2, n3];
     n2.parent = n1;
     n3.parent = n1;
     var s = new Serialization()
       ..addRuleFor(n1, constructorFields: ["name"]).
           setFieldWith("children", (parent, child) =>
@@ skipping 33 matching lines @@
     expect(identical(m2.parent, m3.parent), isTrue);
   });
 
   test("Constant values as fields", () {
     var s = new Serialization()
       ..selfDescribing = false
       ..addRuleFor(a1,
           constructor: 'withData',
           constructorFields: ["street", "Kirkland", "WA", "98103"],
           fields: []);
-    String out = s.write(a1);
+    var out = s.write(a1);
     var newAddress = s.read(out);
     expect(newAddress.street, a1.street);
     expect(newAddress.city, "Kirkland");
     expect(newAddress.state, "WA");
     expect(newAddress.zip, "98103");
   });
 
   test("Straight JSON format", () {
     var s = new Serialization();
     var writer = s.newWriter(new SimpleJsonFormat());
-    var out = writer.write(a1);
+    var out = json.stringify(writer.write(a1));
     var reconstituted = json.parse(out);
     expect(reconstituted.length, 4);
     expect(reconstituted[0], "Seattle");
   });
 
   test("Straight JSON format, nested objects", () {
     var p1 = new Person()..name = 'Alice'..address = a1;
-    var s = new Serialization();
+    var s = new Serialization()..selfDescribing = false;
     var addressRule = s.addRuleFor(a1)..configureForMaps();
     var personRule = s.addRuleFor(p1)..configureForMaps();
     var writer = s.newWriter(new SimpleJsonFormat(storeRoundTripInfo: true));
-    var out = writer.write(p1);
+    var out = json.stringify(writer.write(p1));
     var reconstituted = json.parse(out);
     var expected = {
       "name" : "Alice",
       "rank" : null,
       "serialNumber" : null,
-      "__rule" : personRule.number,
+      "_rule" : personRule.number,
       "address" : {
         "street" : "N 34th",
         "city" : "Seattle",
         "state" : null,
         "zip" : null,
-        "__rule" : addressRule.number
+        "_rule" : addressRule.number
       }
     };
     expect(expected, reconstituted);
   });
 
   test("Straight JSON format, round-trip", () {
     // Note that we can't use the usual round-trip test because it has cycles.
     var p1 = new Person()..name = 'Alice'..address = a1;
     // Use maps for one rule, lists for the other.
     var s = new Serialization()
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps();
-    var writer = s.newWriter(new SimpleJsonFormat(storeRoundTripInfo: true));
-    var out = writer.write(p1);
-    var reader = s.newReader(new SimpleJsonFormat(storeRoundTripInfo: true));
-    var p2 = reader.read(out);
+    var p2 = writeAndReadBack(s,
+        new SimpleJsonFormat(storeRoundTripInfo: true), p1);
     expect(p2.name, "Alice");
     var a2 = p2.address;
     expect(a2.street, "N 34th");
     expect(a2.city, "Seattle");
   });
 
-  test("Straight JSON format, root is a Map", () {
+  test("Root is a Map", () {
     // Note that we can't use the usual round-trip test because it has cycles.
     var p1 = new Person()..name = 'Alice'..address = a1;
     // Use maps for one rule, lists for the other.
     var s = new Serialization()
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps();
-    var format = new SimpleJsonFormat(storeRoundTripInfo: true);
-    var writer = s.newWriter(format);
-    var out = writer.write({"stuff" : p1});
-    var reader = s.newReader(format);
-    var p2 = reader.read(out)["stuff"];
-    expect(p2.name, "Alice");
-    var a2 = p2.address;
+    for (var eachFormat in formats) {
+      var w = s.newWriter(eachFormat);
+      var output = w.write({"stuff" : p1});
+      var r = s.newReader(w.format);
+      var result = r.read(output);
+      var p2 = result["stuff"];
+      expect(p2.name, "Alice");
+      var a2 = p2.address;
+      expect(a2.street, "N 34th");
+      expect(a2.city, "Seattle");
+    }
+  });
+
+  test("Root is a List", () {
+    var s = new Serialization();
+    for (var eachFormat in formats) {
+      var result = writeAndReadBack(s, eachFormat, [a1]);
+    var a2 = result.first;
     expect(a2.street, "N 34th");
     expect(a2.city, "Seattle");
+    }
   });
 
+  test("Root is a simple object", () {
+    var s = new Serialization();
+    for (var eachFormat in formats) {
+      expect(writeAndReadBack(s, eachFormat, null), null);
+      expect(writeAndReadBack(s, eachFormat, [null]), [null]);
+      expect(writeAndReadBack(s, eachFormat, 3), 3);
+      expect(writeAndReadBack(s, eachFormat, [3]), [3]);
+      expect(writeAndReadBack(s, eachFormat, "hello"), "hello");
+      expect(writeAndReadBack(s, eachFormat, [3]), [3]);
+      expect(writeAndReadBack(s, eachFormat, {"hello" : "world"}),
+          {"hello" : "world"});
+      expect(writeAndReadBack(s, eachFormat, true), true);
+    }
+  });
 
-  test("Straight JSON format, round-trip with named objects", () {
+  test("Simple JSON format, round-trip with named objects", () {
     // Note that we can't use the usual round-trip test because it has cycles.
     var p1 = new Person()..name = 'Alice'..address = a1;
     // Use maps for one rule, lists for the other.
     var s = new Serialization()
+      ..selfDescribing = false
       ..addRule(new NamedObjectRule())
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps()
       ..namedObjects["foo"] = a1;
     var writer = s.newWriter(new SimpleJsonFormat(storeRoundTripInfo: true));
     var out = writer.write(p1);
     var reader = s.newReader(new SimpleJsonFormat(storeRoundTripInfo: true));
     var p2 = reader.read(out, {"foo" : 12});
     expect(p2.name, "Alice");
     var a2 = p2.address;
     expect(a2, 12);
   });
 
-  test("Maps", () {
+  test("More complicated Maps", () {
     var s = new Serialization()..selfDescribing = false;
     var p1 = new Person()..name = 'Alice'..address = a1;
     var data = new Map();
     data["simple data"] = 1;
     data[p1] = a1;
     data[a1] = p1;
-    var formats = [new SimpleFlatFormat(), new SimpleMapFormat(),
-        new SimpleJsonFormat(storeRoundTripInfo: true)];
     for (var eachFormat in formats) {
       var output = s.write(data, eachFormat);
       var reader = s.newReader(eachFormat);
       var input = reader.read(output);
       expect(input["simple data"], data["simple data"]);
       var p2 = input.keys.firstMatching((x) => x is Person);
       var a2 = input.keys.firstMatching((x) => x is Address);
       if (eachFormat is SimpleJsonFormat) {
         // JSON doesn't handle cycles, so these won't be identical.
         expect(input[p2] is Address, isTrue);
@@ skipping 12 matching lines @@
       }
     }
   });
 
   test("Map with string keys stays that way", () {
     var s = new Serialization()..addRuleFor(new Person());
     var data = {"abc" : 1, "def" : "ghi"};
     data["person"] = new Person()..name = "Foo";
     var output = s.write(data, new SimpleMapFormat());
     var mapRule = s.rules.firstMatching((x) => x is MapRule);
-    var map = json.parse(output)["data"][mapRule.number][0];
+    var map = output["data"][mapRule.number][0];
     expect(map is Map, isTrue);
     expect(map["abc"], 1);
     expect(map["def"], "ghi");
     expect(new Reader(s).asReference(map["person"]) is Reference, isTrue);
   });
+
 }
 
 /******************************************************************************
  * The end of the tests and the beginning of various helper functions to make
  * it easier to write the repetitive sections.
  ******************************************************************************/
 
+writeAndReadBack(Serialization s, Format format, object) {
+  var w = s.newWriter(format);
+  var output = w.write(object);
+  var r = s.newReader(w.format);
+  return r.read(output);
+}
+
 /** Create a Serialization for serializing Serializations. */
 Serialization metaSerialization() {
   // Make some bogus rule instances so we have something to feed rule creation
   // and get their types. If only we had class literals implemented...
   var basicRule = new BasicRule(reflect(null).type, '', [], [], []);
 
   var meta = new Serialization()
     ..selfDescribing = false
     ..addRuleFor(new ListRule())
     ..addRuleFor(new PrimitiveRule())
     // TODO(alanknight): Handle CustomRule as well.
     // Note that we're passing in a constant for one of the fields.
     ..addRuleFor(basicRule,
         constructorFields: ['type',
           'constructorName',
           'constructorFields', 'regularFields', []],
         fields: [])
      ..addRuleFor(new Serialization(), constructor: "blank")
          .setFieldWith('rules',
            (InstanceMirror s, List rules) {
              rules.forEach((x) => s.reflectee.addRule(x));
            })
     ..addRule(new NamedObjectRule())
-    ..addRule(new MirrorRule());
+    ..addRule(new MirrorRule())
+    ..addRule(new MapRule());
   return meta;
 }
 
+Serialization metaSerializationUsingMaps() {
+  var meta = metaSerialization();
+  meta.rules.where((each) => each is BasicRule)
+      .forEach((x) => x.configureForMaps());
+  return meta;
+}
+
 /**
  * Read back a simple object, assumed to be the only one of its class in the
  * reader.
  */
 readBackSimple(Serialization s, object, Reader reader) {
   var rule = s.rulesFor(object, null).first;
   reader.inflateForRule(rule);
   var list2 = reader.allObjectsForRule(rule).first;
   return list2;
 }
 
 /**
  * Set up a basic reader with some fake data. Hard-codes the assumption
  * of how many rules there are.
  */
 Reader setUpReader(aSerialization, sampleData) {
   var reader = new Reader(aSerialization);
   // We're not sure which rule needs the sample data, so put it everywhere
   // and trust that the extra will just be ignored.
+
   var fillValue = [sampleData];
   var data = [];
   for (int i = 0; i < 10; i++) {
     data.add(fillValue);
   }
   reader.data = data;
   return reader;
 }
 
 /** Return a serialization for Node objects, using a reflective rule. */
@@ skipping 106 matching lines @@
   expect(m2.name, "2");
   expect(m3.name, "3");
   expect(m2.parent, m1);
   expect(m3.parent, m1);
   expect(m1.parent, isNull);
 }
 
 /** Extract the state from [object] using the rules in [s] and return it. */
 states(object, Serialization s) {
   var rules = s.rulesFor(object, null);
-  return rules.map((x) => x.extractState(object, doNothing)).toList();
+  return rules.map((x) => x.extractState(object, doNothing, null)).toList();
 }
 
 /** A hard-coded rule for serializing Node instances. */
 class NodeRule extends CustomRule {
   bool appliesTo(instance, _) => instance.runtimeType == Node;
   getState(instance) => [instance.parent, instance.name, instance.children];
   create(state) => new Node(state[1]);
   setState(Node node, state) {
     node.parent = state[0];
     node.children = state[2];
   }
 }