Merge branch 'collectd-5.5'
[collectd.git] / src / utils_vl_lookup_test.c
1 /**
2  * collectd - src/tests/test_utils_vl_lookup.c
3  * Copyright (C) 2012       Florian Forster
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Florian Forster <octo at collectd.org>
25  **/
26
27 #include "testing.h"
28 #include "collectd.h"
29 #include "utils_vl_lookup.h"
30
31 static _Bool expect_new_obj = 0;
32 static _Bool have_new_obj = 0;
33
34 static identifier_t last_class_ident;
35 static identifier_t last_obj_ident;
36
37 static data_source_t dsrc_test = { "value", DS_TYPE_DERIVE, 0.0, NAN };
38 static data_set_t const ds_test = { "test", 1, &dsrc_test };
39
40 static data_source_t dsrc_unknown = { "value", DS_TYPE_DERIVE, 0.0, NAN };
41 static data_set_t const ds_unknown = { "unknown", 1, &dsrc_unknown };
42
43 static int lookup_obj_callback (data_set_t const *ds,
44     value_list_t const *vl,
45     void *user_class, void *user_obj)
46 {
47   identifier_t *class = user_class;
48   identifier_t *obj = user_obj;
49
50   OK1(expect_new_obj == have_new_obj,
51       (expect_new_obj ? "New obj is created." : "Updating existing obj."));
52
53   memcpy (&last_class_ident, class, sizeof (last_class_ident));
54   memcpy (&last_obj_ident, obj, sizeof (last_obj_ident));
55
56   if (strcmp (obj->plugin_instance, "failure") == 0)
57     return (-1);
58
59   return (0);
60 }
61
62 static void *lookup_class_callback (data_set_t const *ds,
63     value_list_t const *vl, void *user_class)
64 {
65   identifier_t *class = user_class;
66   identifier_t *obj;
67
68   assert (expect_new_obj);
69
70   memcpy (&last_class_ident, class, sizeof (last_class_ident));
71   
72   obj = malloc (sizeof (*obj));
73   strncpy (obj->host, vl->host, sizeof (obj->host));
74   strncpy (obj->plugin, vl->plugin, sizeof (obj->plugin));
75   strncpy (obj->plugin_instance, vl->plugin_instance, sizeof (obj->plugin_instance));
76   strncpy (obj->type, vl->type, sizeof (obj->type));
77   strncpy (obj->type_instance, vl->type_instance, sizeof (obj->type_instance));
78
79   have_new_obj = 1;
80
81   return ((void *) obj);
82 }
83
84 static int checked_lookup_add (lookup_t *obj, /* {{{ */
85     char const *host,
86     char const *plugin, char const *plugin_instance,
87     char const *type, char const *type_instance,
88     unsigned int group_by)
89 {
90   identifier_t ident;
91   void *user_class;
92
93   memset (&ident, 0, sizeof (ident));
94   strncpy (ident.host, host, sizeof (ident.host));
95   strncpy (ident.plugin, plugin, sizeof (ident.plugin));
96   strncpy (ident.plugin_instance, plugin_instance, sizeof (ident.plugin_instance));
97   strncpy (ident.type, type, sizeof (ident.type));
98   strncpy (ident.type_instance, type_instance, sizeof (ident.type_instance));
99
100   user_class = malloc (sizeof (ident));
101   memmove (user_class, &ident, sizeof (ident));
102
103   OK(lookup_add (obj, &ident, group_by, user_class) == 0);
104   return 0;
105 } /* }}} int checked_lookup_add */
106
107 static int checked_lookup_search (lookup_t *obj,
108     char const *host,
109     char const *plugin, char const *plugin_instance,
110     char const *type, char const *type_instance,
111     _Bool expect_new)
112 {
113   int status;
114   value_list_t vl = VALUE_LIST_STATIC;
115   data_set_t const *ds = &ds_unknown;
116
117   strncpy (vl.host, host, sizeof (vl.host));
118   strncpy (vl.plugin, plugin, sizeof (vl.plugin));
119   strncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
120   strncpy (vl.type, type, sizeof (vl.type));
121   strncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
122
123   if (strcmp (vl.type, "test") == 0)
124     ds = &ds_test;
125
126   expect_new_obj = expect_new;
127   have_new_obj = 0;
128
129   status = lookup_search (obj, ds, &vl);
130   return (status);
131 }
132
133 DEF_TEST(group_by_specific_host)
134 {
135   lookup_t *obj;
136   CHECK_NOT_NULL (obj = lookup_create (
137         lookup_class_callback, lookup_obj_callback, (void *) free, (void *) free));
138
139   checked_lookup_add (obj, "/.*/", "test", "", "test", "/.*/", LU_GROUP_BY_HOST);
140   checked_lookup_search (obj, "host0", "test", "", "test", "0",
141       /* expect new = */ 1);
142   checked_lookup_search (obj, "host0", "test", "", "test", "1",
143       /* expect new = */ 0);
144   checked_lookup_search (obj, "host1", "test", "", "test", "0",
145       /* expect new = */ 1);
146   checked_lookup_search (obj, "host1", "test", "", "test", "1",
147       /* expect new = */ 0);
148
149   lookup_destroy (obj);
150   return (0);
151 }
152
153 DEF_TEST(group_by_any_host)
154 {
155   lookup_t *obj;
156   CHECK_NOT_NULL (obj = lookup_create (
157         lookup_class_callback, lookup_obj_callback, (void *) free, (void *) free));
158
159   checked_lookup_add (obj, "/.*/", "/.*/", "/.*/", "test", "/.*/", LU_GROUP_BY_HOST);
160   checked_lookup_search (obj, "host0", "plugin0", "", "test", "0",
161       /* expect new = */ 1);
162   checked_lookup_search (obj, "host0", "plugin0", "", "test", "1",
163       /* expect new = */ 0);
164   checked_lookup_search (obj, "host0", "plugin1", "", "test", "0",
165       /* expect new = */ 0);
166   checked_lookup_search (obj, "host0", "plugin1", "", "test", "1",
167       /* expect new = */ 0);
168   checked_lookup_search (obj, "host1", "plugin0", "", "test", "0",
169       /* expect new = */ 1);
170   checked_lookup_search (obj, "host1", "plugin0", "", "test", "1",
171       /* expect new = */ 0);
172   checked_lookup_search (obj, "host1", "plugin1", "", "test", "0",
173       /* expect new = */ 0);
174   checked_lookup_search (obj, "host1", "plugin1", "", "test", "1",
175       /* expect new = */ 0);
176
177   lookup_destroy (obj);
178   return (0);
179 }
180
181 DEF_TEST(multiple_lookups)
182 {
183   lookup_t *obj;
184   int status;
185
186   CHECK_NOT_NULL (obj = lookup_create (
187         lookup_class_callback, lookup_obj_callback, (void *) free, (void *) free));
188
189   checked_lookup_add (obj, "/.*/", "plugin0", "", "test", "/.*/", LU_GROUP_BY_HOST);
190   checked_lookup_add (obj, "/.*/", "/.*/", "", "test", "ti0", LU_GROUP_BY_HOST);
191
192   status = checked_lookup_search (obj, "host0", "plugin1", "", "test", "",
193       /* expect new = */ 0);
194   assert (status == 0);
195   status = checked_lookup_search (obj, "host0", "plugin0", "", "test", "",
196       /* expect new = */ 1);
197   assert (status == 1);
198   status = checked_lookup_search (obj, "host0", "plugin1", "", "test", "ti0",
199       /* expect new = */ 1);
200   assert (status == 1);
201   status = checked_lookup_search (obj, "host0", "plugin0", "", "test", "ti0",
202       /* expect new = */ 0);
203   assert (status == 2);
204
205   lookup_destroy (obj);
206   return (0);
207 }
208
209 DEF_TEST(regex)
210 {
211   lookup_t *obj;
212   CHECK_NOT_NULL (obj = lookup_create (
213         lookup_class_callback, lookup_obj_callback, (void *) free, (void *) free));
214
215   checked_lookup_add (obj, "/^db[0-9]\\./", "cpu", "/.*/", "cpu", "/.*/",
216       LU_GROUP_BY_TYPE_INSTANCE);
217   checked_lookup_search (obj, "db0.example.com", "cpu", "0", "cpu", "user",
218       /* expect new = */ 1);
219   checked_lookup_search (obj, "db0.example.com", "cpu", "0", "cpu", "idle",
220       /* expect new = */ 1);
221   checked_lookup_search (obj, "db0.example.com", "cpu", "1", "cpu", "user",
222       /* expect new = */ 0);
223   checked_lookup_search (obj, "db0.example.com", "cpu", "1", "cpu", "idle",
224       /* expect new = */ 0);
225   checked_lookup_search (obj, "app0.example.com", "cpu", "0", "cpu", "user",
226       /* expect new = */ 0);
227   checked_lookup_search (obj, "app0.example.com", "cpu", "0", "cpu", "idle",
228       /* expect new = */ 0);
229   checked_lookup_search (obj, "db1.example.com", "cpu", "0", "cpu", "user",
230       /* expect new = */ 0);
231   checked_lookup_search (obj, "db1.example.com", "cpu", "0", "cpu", "idle",
232       /* expect new = */ 0);
233   checked_lookup_search (obj, "db1.example.com", "cpu", "0", "cpu", "system",
234       /* expect new = */ 1);
235
236   lookup_destroy (obj);
237   return (0);
238 }
239
240 int main (int argc, char **argv) /* {{{ */
241 {
242   RUN_TEST(group_by_specific_host);
243   RUN_TEST(group_by_any_host);
244   RUN_TEST(multiple_lookups);
245   RUN_TEST(regex);
246
247   END_TEST;
248 } /* }}} int main */