1
exercism fetch elixir dot-dsl

dot_dsl_test.exs

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
if !System.get_env("EXERCISM_TEST_EXAMPLES") do
  Code.load_file("dot.exs", __DIR__)
end

ExUnit.start
ExUnit.configure exclude: :pending, trace: true

defmodule DotTest do
  use ExUnit.Case
  require Dot

  # Expand at RunTime, used to avoid invalid macro calls preventing compilation
  # of the tests.
  #
  # Inspired by (read: clone of) Support.CompileHelpers.delay_compile in Ecto.
  defmacrop exprt(ast) do
    escaped = Macro.escape(ast)
    quote do
      Code.eval_quoted(unquote(escaped), [], __ENV__) |> elem(0)
    end
  end

  # @tag :pending
  test "empty graph" do
    assert %Graph{} == exprt(Dot.graph do end)
  end

  @tag :pending
  test "graph with one node" do
    assert %Graph{nodes: [{:a, []}]} == exprt(Dot.graph do a end)
  end

  @tag :pending
  test "graph with one node with keywords" do
    assert %Graph{nodes: [{:a, [color: :green]}]} == exprt(Dot.graph do a [color: :green] end)
  end

  @tag :pending
  test "graph with one edge" do
    assert %Graph{edges: [{:a, :b, []}]} == exprt(Dot.graph do a -- b end)
  end

  @tag :pending
  test "graph with just attribute" do
    assert %Graph{attrs: [foo: 1]} == exprt(Dot.graph do graph [foo: 1] end)
  end

  @tag :pending
  test "graph with attributes" do
    assert %Graph{
      attrs: [bar: true, foo: 1, title: "Testing Attrs"],
      nodes: [{:a, [color: :green]},
              {:b, [label: "Beta!"]},
              {:c, []}],
      edges: [{:a, :b, [color: :blue]},
              {:b, :c, []}]
    } == exprt(Dot.graph do
      graph [foo: 1]
      graph [title: "Testing Attrs"]
      graph []
      a [color: :green]
      c []
      b [label: "Beta!"]
      b -- c []
      a -- b [color: :blue]
      graph [bar: true]
    end)
  end

  @tag :pending
  test "keywords stuck to graph without space" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        graph[title: "Bad"]
      end)
    end
  end

  @tag :pending
  test "keywords stuck to node without space" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        a[label: "Alpha!"]
      end)
    end
  end

  @tag :pending
  test "keywords stuck to edge without space" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        a -- b[label: "Bad"]
      end)
    end
  end

  @tag :pending
  test "invalid statement: int" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        a
        2
      end)
    end
  end

  @tag :pending
  test "invalid statement: list" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        [title: "Testing invalid"]
      end)
    end
  end

  @tag :pending
  test "invalid statement: qualified atom" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        Enum.map
      end)
    end
  end

  @tag :pending
  test "invalid statement: graph with no keywords" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        Enum.map
      end)
    end
  end

  @tag :pending
  test "two attribute lists" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        a [color: green][label: "Alpha!"]
      end) |> IO.inspect
    end
  end

  @tag :pending
  test "non-keyword attribute list" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        a ["Alpha!", color: green]
      end)
    end
  end

  @tag :pending
  test "int edge" do
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        1 -- b
      end)
    end
    assert_raise ArgumentError, fn ->
      exprt(Dot.graph do
        a -- 2
      end)
    end
  end
end