Make input/output formats pluggable, adapt to new libraries

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();
@@ skipping 212 matching lines @@
   });
 
   test('round-trip, flat format', () {
     runRoundTripTestFlat(nodeSerializerReflective);
   });
 
   test('round-trip using Maps', () {
     runRoundTripTest(nodeSerializerUsingMaps);
   });
 
+  test('round-trip, flat format, using maps', () {
+    runRoundTripTestFlat(nodeSerializerUsingMaps);
+  });
+
   test('round-trip with Node CustomRule', () {
     runRoundTripTestFlat(nodeSerializerCustom);
   });
 
   test('round-trip with Node CustomRule, to maps', () {
     runRoundTripTest(nodeSerializerCustom);
   });
 
   test('eating your own tail', () {
     // Create a meta-serializer, that serializes serializations, then
@@ skipping 53 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: []);
-    var out = s.write(a1);
+    String 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", () {

[Jennifer Messerly, 2013/01/11 02:21:53]

what's the status of this test?

[Alan Knight, 2013/01/11 19:18:11]

Oops. Restored.

+//    var s = new Serialization();
+//    var writer = s.newWriter(new SimpleJSONFormat());
+//    var out = 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()
+      ..addRuleFor(a1).configureForMaps()
+      ..addRuleFor(p1).configureForMaps();
+    var writer = s.newWriter(new SimpleJSONFormat(true));
+    var out = writer.write(p1);
+    var reconstituted = json.parse(out);

[Jennifer Messerly, 2013/01/11 02:21:53]

it would be interesting to see the full JSON map here, e.g.

expected(json.parse(out), {
  'name': 'Alice',
  'rank': null,
  'serialNumber': null,
  'address': { 'street': 'N 34th', 'city': 'Seatte',
               'state': null, 'zip', null, ... }
  ...
});

I think matchers can compare maps?

[Alan Knight, 2013/01/11 19:18:11]

Nice. Done.

+    expect(reconstituted.length, 5);
+    expect(reconstituted["name"], "Alice");
+    var address = reconstituted["address"];
+    expect(address.length, 5);
+    expect(address["street"], "N 34th");
+  });
+
+  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(true));
+    var out = writer.write(p1);
+    var reader = s.newReader(new SimpleJSONFormat(true));
+    var p2 = reader.read(out);
+    expect(p2.name, "Alice");
+    var a2 = p2.address;
+    expect(a2.street, "N 34th");
+    expect(a2.city, "Seattle");
+  });
+
+  test("Straight 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()
+      ..addRule(new NamedObjectRule())
+      ..addRuleFor(a1)
+      ..addRuleFor(p1).configureForMaps()
+      ..namedObjects["foo"] = a1;
+    var writer = s.newWriter(new SimpleJSONFormat(true));
+    var out = writer.write(p1);
+    var reader = s.newReader(new SimpleJSONFormat(true));
+    var p2 = reader.read(out, {"foo" : 12});
+    expect(p2.name, "Alice");
+    var a2 = p2.address;
+    expect(a2, 12);
+  });
 }
 
 /******************************************************************************
  * The end of the tests and the beginning of various helper functions to make
  * it easier to write the repetitive sections.
  ******************************************************************************/
 
 /** Create a Serialization for serializing Serializations. */
 Serialization metaSerialization() {
   // Make some bogus rule instances so we have something to feed rule creation
@@ skipping 18 matching lines @@
     ..addRule(new NamedObjectRule())
     ..addRule(new MirrorRule());
   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)[0];
+  var rule = s.rulesFor(object, null).first;
   reader.inflateForRule(rule);
-  var list2 = reader.allObjectsForRule(rule)[0];
+  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
@@ skipping 92 matching lines @@
 /**
  * Run a round-trip test on a simple of nodes, but using the flat format
  * rather than the maps.
  */
 runRoundTripTestFlat(serializerSetUp) {
   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 = serializerSetUp(n1);
-  var output = s.writeFlat(n2);
+  var output = s.write(n2, new SimpleFlatFormat());
   expect(output is List, isTrue);
   var s2 = serializerSetUp(n1);
-  var reader = new Reader(s2);
-  var m2 = reader.readFlat(output);
+  var reader = new Reader(s2, new SimpleFlatFormat());
+  var m2 = reader.read(output);
   var m1 = m2.parent;
   expect(m1 is Node, isTrue);
   var children = m1.children;
   expect(m1.name,"1");
   var m3 = m1.children.last;
   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.mappedBy((x) => x.extractState(object, doNothing)).toList();
 }
 
 /** A hard-coded rule for serializing Node instances. */
 class NodeRule extends CustomRule {
-  bool appliesTo(instance, _) => instance is Node;
+  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];
   }
 }