d3-shape/test/link-test.js at 46845319448e166e51345a569c728d9c1c71e7d6 · d3/d3-shape · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
import assert from "assert";
import {pathRound} from "d3-path";
import {link, linkHorizontal, linkVertical} from "../src/index.js";
import {curveLinear, curveBumpX, curveBumpY} from "../src/index.js";
import {assertPathEqual} from "./asserts.js";

it("link(curve) returns a default link with the given curve", () => {
  const l = link(curveLinear);
  assert.strictEqual(l.source()({source: 42}), 42);
  assert.strictEqual(l.target()({target: 34}), 34);
  assert.strictEqual(l.x()([42, 34]), 42);
  assert.strictEqual(l.y()([42, 34]), 34);
  assert.strictEqual(l.context(), null);
  assertPathEqual(l({source: [0, 1], target: [2, 3]}), "M0,1L2,3");
});

it("link.source(source) sets source", () => {
  const l = link(curveLinear);
  const x = d => d.x;
  assert.strictEqual(l.source(x), l);
  assert.strictEqual(l.source(), x);
  assertPathEqual(l({x: [0, 1], target: [2, 3]}), "M0,1L2,3");
});

it("link.target(target) sets target", () => {
  const l = link(curveLinear);
  const x = d => d.x;
  assert.strictEqual(l.target(x), l);
  assert.strictEqual(l.target(), x);
  assertPathEqual(l({source: [0, 1], x: [2, 3]}), "M0,1L2,3");
});

it("link.source(f)(..args) passes arguments to the specified function f", () => {
  const source = {name: "source"};
  const target = {name: "target"};
  const data = {source, target};
  const extra = {name: "extra"};
  const actual = [];
  link(curveLinear).source(function(d) { actual.push([].slice.call(arguments)); return d; })(data, extra);
  assert.deepStrictEqual(actual, [[data, extra]]);
});

it("link.target(f)(..args) passes source and arguments to the specified function f", () => {
  const source = {name: "source"};
  const target = {name: "target"};
  const data = {source, target};
  const extra = {name: "extra"};
  const actual = [];
  link(curveLinear).target(function(d) { actual.push([].slice.call(arguments)); return d; })(data, extra);
  assert.deepStrictEqual(actual, [[data, extra]]);
});

it("link.x(x) sets x", () => {
  const l = link(curveLinear);
  const x = d => d.x;
  assert.strictEqual(l.x(x), l);
  assert.strictEqual(l.x(), x);
  assertPathEqual(l({source: {x: 0, 1: 1}, target: {x: 2, 1: 3}}), "M0,1L2,3");
});

it("link.y(y) sets y", () => {
  const l = link(curveLinear);
  const y = d => d.y;
  assert.strictEqual(l.y(y), l);
  assert.strictEqual(l.y(), y);
  assertPathEqual(l({source: {0: 0, y: 1}, target: {0: 2, y: 3}}), "M0,1L2,3");
});

it("link.x(f)(..args) passes source and arguments to the specified function f", () => {
  const source = {name: "source"};
  const target = {name: "target"};
  const data = {source, target};
  const extra = {name: "extra"};
  const actual = [];
  link(curveLinear).x(function() { actual.push([].slice.call(arguments)); })(data, extra);
  assert.deepStrictEqual(actual, [[source, extra], [target, extra]]);
});

it("link.y(f)(..args) passes source and arguments to the specified function f", () => {
  const source = {name: "source"};
  const target = {name: "target"};
  const data = {source, target};
  const extra = {name: "extra"};
  const actual = [];
  link(curveLinear).y(function() { actual.push([].slice.call(arguments)); })(data, extra);
  assert.deepStrictEqual(actual, [[source, extra], [target, extra]]);
});

it("linkHorizontal() is an alias for link(curveBumpX)", () => {
  const l = linkHorizontal(), l2 = link(curveBumpX);
  assert.strictEqual(l.source(), l2.source());
  assert.strictEqual(l.target(), l2.target());
  assert.strictEqual(l.x(), l2.x());
  assert.strictEqual(l.y(), l2.y());
  assert.strictEqual(l.context(), l2.context());
  assertPathEqual(l({source: [0, 1], target: [2, 3]}), l2({source: [0, 1], target: [2, 3]}));
});

it("linkVertical() is an alias for link(curveBumpY)", () => {
  const l = linkVertical(), l2 = link(curveBumpY);
  assert.strictEqual(l.source(), l2.source());
  assert.strictEqual(l.target(), l2.target());
  assert.strictEqual(l.x(), l2.x());
  assert.strictEqual(l.y(), l2.y());
  assert.strictEqual(l.context(), l2.context());
  assertPathEqual(l({source: [0, 1], target: [2, 3]}), l2({source: [0, 1], target: [2, 3]}));
});

it("link.context(context) sets the context", () => {
  const p = pathRound(6);
  const l = link(curveLinear).context(p);
  assert.strictEqual(l({source: [0, Math.E], target: [Math.PI, 3]}), undefined);
  assert.strictEqual(p + "", "M0,2.718282L3.141593,3");
});