it("sets proper document on models added during construction", () => {
    const d = new Document()
    expect(d.roots().length).to.equal(0)
    expect(Object.keys(d._all_models).length).to.equal(0)

    const root1 = new ModelWithConstructTimeChanges()
    // change it so it doesn't match what initialize() does
    root1.foo = 3
    root1.child = null
    d.add_root(root1)

    const json = d.to_json_string()
    const parsed = JSON.parse(json)
    parsed.version = js_version
    const copy = Document.from_json_string(JSON.stringify(parsed))

    const root1_copy = copy.get_model_by_id(root1.id) as ModelWithConstructTimeChanges

    expect(root1.foo).to.equal(3)
    expect(root1.child).to.equal(null)

    // when unpacking the copy, initialize() was supposed to overwrite
    // what we unpacked.
    expect(root1_copy.foo).to.equal(4)
    expect(root1_copy.child).to.be.an.instanceof(AnotherModel)
    expect(root1_copy.document).to.equal(copy)
    expect(root1_copy.child!.document).to.equal(copy)
  })

  beforeEach(() => {
    const doc = new Document()

    const plot = new Plot({
       x_range: new Range1d({start: 0, end: 1}),
       y_range: new Range1d({start: 0, end: 1}),
    })
    doc.add_root(plot)
    const plot_view = new plot.default_view({model: plot, parent: null}).build()

    node_source = new ColumnDataSource({
      data: {
        index: [10, 20, 30, 40],
      },
    })
    edge_source = new ColumnDataSource({
      data: {
        start: [10, 10, 30],
        end: [20, 30, 20],
      },
    })
    const node_renderer = new GlyphRenderer({data_source: node_source, glyph: new Circle()})
    const edge_renderer = new GlyphRenderer({data_source: edge_source, glyph: new MultiLine()})

    gr = new GraphRenderer({
      node_renderer,
      edge_renderer,
      layout_provider: new TrivialLayoutProvider(),
    })

    gv = new gr.default_view({model: gr, parent: plot_view}) as GraphRendererView

    node_stub = sinon.stub(gv.node_view.glyph, "hit_test")
    edge_stub = sinon.stub(gv.edge_view.glyph, "hit_test")
  })

export function create_glyph_renderer_view(glyph: Glyph, data: {[key: string]: Arrayable} = {}): GlyphRendererView {
  /*
   * Requires stubbing the canvas and solver before calling.
   */
  const doc = new Document()
  const plot = new Plot({
    x_range: new Range1d({start: 0, end: 1}),
    y_range: new Range1d({start: 0, end: 1}),
  })
  const plot_view = new plot.default_view({model: plot, parent: null}) as PlotView
  doc.add_root(plot)

  const plot_canvas_view = plot_view.plot_canvas_view
  sinon.stub(plot_canvas_view, "update_constraints")

  const data_source = new ColumnDataSource({data})

  const glyph_renderer = new GlyphRenderer({
    glyph,
    data_source: data_source,
  })

  const glyph_renderer_view = new glyph_renderer.default_view({
    model: glyph_renderer,
    plot_view: plot_canvas_view,
    parent: plot_canvas_view,
  }) as GlyphRendererView

  return glyph_renderer_view
}

 function mkplot(tool: Tool): PlotView {
   const plot = new Plot({
     x_range: new Range1d({start: -1, end: 1}),
     y_range: new Range1d({start: -1, end: 1}),
   })
   plot.add_tools(tool)
   const document = new Document()
   document.add_root(plot)
   return new plot.default_view({model: plot, parent: null}).build()
 }

 it("should round-trip through document serialization", () => {
   const d = new Document()
   d.add_root(r)
   const json = d.to_json_string()
   const parsed = JSON.parse(json)
   parsed.version = js_version
   const copy = Document.from_json_string(JSON.stringify(parsed))
   const r_copy = copy.get_model_by_id(r.id)! as CustomJSHover
   const rng_copy = copy.get_model_by_id(rng.id)! as CustomJSHover
   expect(r.values).to.be.deep.equal([rng])
   expect(r_copy.values).to.be.deep.equal([rng_copy])
 })