1package dependency
2
3import (
4	"fmt"
5	"testing"
6
7	"github.com/stretchr/testify/assert"
8)
9
10func TestNewCatalogNodeQuery(t *testing.T) {
11	t.Parallel()
12
13	cases := []struct {
14		name string
15		i    string
16		exp  *CatalogNodeQuery
17		err  bool
18	}{
19		{
20			"empty",
21			"",
22			&CatalogNodeQuery{},
23			false,
24		},
25		{
26			"bad",
27			"!4d",
28			nil,
29			true,
30		},
31		{
32			"dc_only",
33			"@dc1",
34			nil,
35			true,
36		},
37		{
38			"node",
39			"node",
40			&CatalogNodeQuery{
41				name: "node",
42			},
43			false,
44		},
45		{
46			"dc",
47			"node@dc1",
48			&CatalogNodeQuery{
49				name: "node",
50				dc:   "dc1",
51			},
52			false,
53		},
54		{
55			"periods",
56			"node.bar.com@dc1",
57			&CatalogNodeQuery{
58				name: "node.bar.com",
59				dc:   "dc1",
60			},
61			false,
62		},
63	}
64
65	for i, tc := range cases {
66		t.Run(fmt.Sprintf("%d_%s", i, tc.name), func(t *testing.T) {
67			act, err := NewCatalogNodeQuery(tc.i)
68			if (err != nil) != tc.err {
69				t.Fatal(err)
70			}
71
72			if act != nil {
73				act.stopCh = nil
74			}
75
76			assert.Equal(t, tc.exp, act)
77		})
78	}
79}
80
81func TestCatalogNodeQuery_Fetch(t *testing.T) {
82	t.Parallel()
83
84	cases := []struct {
85		name string
86		i    string
87		exp  *CatalogNode
88	}{
89		{
90			"local",
91			"",
92			&CatalogNode{
93				Node: &Node{
94					Node:       testConsul.Config.NodeName,
95					Address:    testConsul.Config.Bind,
96					Datacenter: "dc1",
97					TaggedAddresses: map[string]string{
98						"lan": "127.0.0.1",
99						"wan": "127.0.0.1",
100					},
101					Meta: map[string]string{
102						"consul-network-segment": "",
103					},
104				},
105				Services: []*CatalogNodeService{
106					&CatalogNodeService{
107						ID:      "consul",
108						Service: "consul",
109						Port:    testConsul.Config.Ports.Server,
110						Tags:    ServiceTags([]string{}),
111						Meta:    map[string]string{},
112					},
113					&CatalogNodeService{
114						ID:      "foo",
115						Service: "foo-sidecar-proxy",
116						Tags:    ServiceTags([]string{}),
117						Meta:    map[string]string{},
118						Port:    21999,
119					},
120					&CatalogNodeService{
121						ID:      "service-meta",
122						Service: "service-meta",
123						Tags:    ServiceTags([]string{"tag1"}),
124						Meta: map[string]string{
125							"meta1": "value1",
126						},
127					},
128					&CatalogNodeService{
129						ID:      "service-taggedAddresses",
130						Service: "service-taggedAddresses",
131						Tags:    ServiceTags([]string{}),
132						Meta:    map[string]string{},
133					},
134				},
135			},
136		},
137		{
138			"unknown",
139			"not_a_real_node",
140			&CatalogNode{},
141		},
142	}
143
144	for i, tc := range cases {
145		t.Run(fmt.Sprintf("%d_%s", i, tc.name), func(t *testing.T) {
146			d, err := NewCatalogNodeQuery(tc.i)
147			if err != nil {
148				t.Fatal(err)
149			}
150
151			act, _, err := d.Fetch(testClients, nil)
152			if err != nil {
153				t.Fatal(err)
154			}
155
156			if act != nil {
157				if n := act.(*CatalogNode).Node; n != nil {
158					n.ID = ""
159					n.TaggedAddresses = filterAddresses(n.TaggedAddresses)
160				}
161				// delete any version data from ServiceMeta
162				services := act.(*CatalogNode).Services
163				for i := range services {
164					services[i].Meta = filterVersionMeta(services[i].Meta)
165				}
166			}
167
168			assert.Equal(t, tc.exp, act)
169		})
170	}
171}
172
173func TestCatalogNodeQuery_String(t *testing.T) {
174	t.Parallel()
175
176	cases := []struct {
177		name string
178		i    string
179		exp  string
180	}{
181		{
182			"empty",
183			"",
184			"catalog.node",
185		},
186		{
187			"node",
188			"node1",
189			"catalog.node(node1)",
190		},
191		{
192			"datacenter",
193			"node1@dc1",
194			"catalog.node(node1@dc1)",
195		},
196	}
197
198	for i, tc := range cases {
199		t.Run(fmt.Sprintf("%d_%s", i, tc.name), func(t *testing.T) {
200			d, err := NewCatalogNodeQuery(tc.i)
201			if err != nil {
202				t.Fatal(err)
203			}
204			assert.Equal(t, tc.exp, d.String())
205		})
206	}
207}
208