Debian Codegraph @

src/mdevents_test.c

raw
1 /**
2 * collectd - src/intel_md_events_test.c
3 *
4 * Copyright(c) 2018 Intel Corporation. All rights reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 *
24 * Authors:
25 * Krzysztof Kazimierczak <[email protected]>
26 * Maciej Fijalkowski <[email protected]>
27 **/
28
29 #include "mdevents.c"
30 #include "testing.h"
31
32 DEF_TEST(classify_event) {
33 int ret;
34 ret = md_events_classify_event("Fail");
35 EXPECT_EQ_INT(NOTIF_FAILURE, ret);
36
37 ret = md_events_classify_event("SparesMissing");
38 EXPECT_EQ_INT(NOTIF_WARNING, ret);
39
40 ret = md_events_classify_event("NewArray");
41 EXPECT_EQ_INT(NOTIF_OKAY, ret);
42
43 ret = md_events_classify_event("UnsupportedEvent");
44 EXPECT_EQ_INT(0, ret);
45
46 return 0;
47 }
48
49 DEF_TEST(compile_regex) {
50 int ret;
51 regex_t r;
52
53 ret = md_events_compile_regex(&r, "^(test|example).+regex[0-9]$");
54 EXPECT_EQ_INT(ret, 0);
55
56 // Compiling invalid regex causes memory leak:
57 // https://bugzilla.redhat.com/show_bug.cgi?id=1049743
58 // ret = md_events_compile_regex(&r, "^$^(oooo|MmaA nnn,d[[[14-1]");
59 // EXPECT_EQ_INT(ret, -1);
60
61 regfree(&r);
62 return 0;
63 }
64
65 DEF_TEST(config) {
66 int ret;
67 ret = md_events_config("Event", "DeviceDisappeared");
68 EXPECT_EQ_INT(ret, 0);
69 ret = md_events_config("Event", "WrongEvent");
70 EXPECT_EQ_INT(ret, -1);
71 ret = md_events_config("Array", "/dev/md0");
72 EXPECT_EQ_INT(ret, 0);
73 ret = md_events_config("Array", "WrongArrayName");
74 EXPECT_EQ_INT(ret, -1);
75
76 ret = md_events_config("IgnoreArray", "True");
77 EXPECT_EQ_INT(ret, 0);
78 ret = md_events_config("IgnoreArray", "False");
79 EXPECT_EQ_INT(ret, 0);
80 ret = md_events_config("IgnoreArray", "Talse");
81 EXPECT_EQ_INT(ret, -1);
82
83 ret = md_events_config("IgnoreEvent", "True");
84 EXPECT_EQ_INT(ret, 0);
85 ret = md_events_config("IgnoreEvent", "False");
86 EXPECT_EQ_INT(ret, 0);
87 ret = md_events_config("IgnoreEvent", "Frue");
88 EXPECT_EQ_INT(ret, -1);
89
90 return 0;
91 }
92
93 DEF_TEST(copy_match) {
94 char *test_str = "This is a test string to be used as an input for "
95 "md_events_copy_match";
96 regmatch_t match = {.rm_so = 10, .rm_eo = 20};
97 md_events_event_t event = {};
98
99 md_events_copy_match(event.event_name, test_str, match);
100 EXPECT_EQ_STR(event.event_name, "test strin");
101
102 // check the out of bounds
103
104 return 0;
105 }
106
107 DEF_TEST(dispatch_notification) {
108 int ret;
109 char buf[130];
110
111 memset(buf, 'a', 129);
112 buf[129] = '\0';
113
114 ret = md_events_dispatch_notification(NULL, NULL);
115 EXPECT_EQ_INT(ret, -1);
116
117 md_events_event_t e = {.event_name = "Fail",
118 .md_device = "/dev/md1",
119 .component_device = "/dev/sda1"};
120
121 ret = md_events_dispatch_notification(&e, NULL);
122 EXPECT_EQ_INT(ret, -1);
123
124 notification_t n = {.severity = NOTIF_FAILURE,
125 .time = cdtime(),
126 .plugin = MD_EVENTS_PLUGIN,
127 .type_instance = ""};
128
129 ret = md_events_dispatch_notification(NULL, &n);
130 EXPECT_EQ_INT(ret, -1);
131
132 ret = md_events_dispatch_notification(&e, &n);
133 EXPECT_EQ_INT(ret, 0);
134
135 return 0;
136 }
137
138 DEF_TEST(get_max_len) {
139 size_t max_name_len = 4;
140 regmatch_t match = {.rm_eo = 2, .rm_so = 1};
141 int ret;
142
143 ret = md_events_get_max_len(match, max_name_len);
144 EXPECT_EQ_INT(ret, 1);
145
146 match.rm_eo *= 10;
147 ret = md_events_get_max_len(match, max_name_len);
148 EXPECT_EQ_INT(ret, max_name_len - 1);
149
150 return 0;
151 }
152
153 DEF_TEST(match_regex) {
154 regex_t r;
155 int ret;
156 static char regex_pattern[] =
157 "mdadm[\\[0-9]+\\]: ([a-zA-Z]+) event detected on md"
158 " device ([a-z0-9\\/\\.\\-]+)[^\\/\n]*([a-z0-9\\/\\.\\-]+)?";
159 const char matching_string[] =
160 "Jan 17 05:24:27 ubuntu-sadev02 mdadm[1848]: "
161 "DeviceDisappeared event detected on md device /dev/md0";
162 const char unmatching_string[] =
163 "mdm[4016] RebuildStarted event detected on md"
164 " device /dev/md127, component device $/dev/sdb";
165 const char unclass_event[] =
166 "Jan 17 05:24:27 ubuntu-sadev02 mdadm[1848]: "
167 "Unclassified event detected on md device /dev/md0";
168
169 md_events_compile_regex(&r, regex_pattern);
170
171 ret = md_events_match_regex(&r, matching_string);
172 EXPECT_EQ_INT(ret, 0);
173
174 ret = md_events_match_regex(&r, unmatching_string);
175 EXPECT_EQ_INT(ret, -1);
176
177 ret = md_events_match_regex(&r, unclass_event);
178 EXPECT_EQ_INT(ret, -1);
179
180 regfree(&r);
181
182 return 0;
183 }
184
185 DEF_TEST(parse_events) {
186 struct {
187 const char *event;
188 size_t len;
189 int ret;
190 } events[] = {{"Fail SpareActive RebuildFinished", 32, 0},
191 {"\0", 1, -1},
192 {"", 0, -1},
193 {"MoveSpare", 9, 0},
194 {"MoveSpare UnclassedEvent", 23, -1},
195 {"MvoeSpare Fail", 14, -1}};
196
197 int ret;
198 for (int i = 0; i < STATIC_ARRAY_SIZE(events); i++) {
199 ret = md_events_parse_events(events[i].event, events[i].len);
200 EXPECT_EQ_INT(ret, events[i].ret);
201 }
202
203 return 0;
204 }
205
206 int main(void) {
207 RUN_TEST(classify_event);
208 // RUN_TEST(compile_regex);
209 RUN_TEST(config);
210 RUN_TEST(copy_match);
211 RUN_TEST(dispatch_notification);
212 RUN_TEST(get_max_len);
213 RUN_TEST(match_regex);
214 RUN_TEST(parse_events);
215 END_TEST;
216 }