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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
|
# -*-coding:utf-8 -*
# Copyright (c) 2011-2015, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
Rules management testcases
List of tested functions :
--------------------------
- [setRule] function
- [clearRule] function
- [getRule] function
Test cases :
------------
- Testing clearRule errors
- Testing setRule errors
- Testing getRule errors
- Testing nominal case
"""
from Util.PfwUnitTestLib import PfwTestCase
from Util import ACTLogging
log=ACTLogging.Logger()
# Test of Domains - Rules
class TestCases(PfwTestCase):
def setUp(self):
self.pfw.sendCmd("setTuningMode", "on")
self.domain_name = "domain_test"
self.conf_1 = "conf_1"
self.conf_2 = "conf_2"
self.rule_1 = "Any{Crit_0 Includes State_0x2, Crit_1 IsNot State_1}"
self.rule_2 = "All{Crit_0 Includes State_0x1, Crit_1 Is State_1}"
self.rule_error_1 = "All{Crit_Error Includes State_0x1, Crit_1 Is State_1}"
self.rule_error_2 = "Any{Crit_0 Includes State_0x2, Crit_0 IsNot State_1}"
self.rule_error_3 = "Ay{Crit_0 Includes State_0x2, Crit_1 IsNot State_1}"
self.rule_error_4 = "All{Crit_0 Includes State_0x4, Crit_1 IsNot State_1}"
self.rule_error_5 = "All{Crit_0 Includes State_0x2, Crit_1 IsNot 1}"
self.rule_error_nbr = 5
def tearDown(self):
self.pfw.sendCmd("setTuningMode", "off")
def test_ClearRule_Errors(self):
"""
Testing configuration creation error
------------------------------------
Test case description :
~~~~~~~~~~~~~~~~~~~~~~~
- Clearing rule on a non-existent configuration
- Clearing rule on a non-existent domain
- Clearing rule with wrong parameters order
Tested commands :
~~~~~~~~~~~~~~~~~
- [clearRule] function
- [setRule] function
- [getRule] function
- [createDomain] function
- [createConfiguration] function
- [deleteDomain] function
Expected result :
~~~~~~~~~~~~~~~~~
- all errors are detected
- no rule is deleted
"""
log.D(self.test_ClearRule_Errors.__doc__)
# New domain creation for testing purpose
log.I("New domain creation for testing purpose : %s" % (self.domain_name))
log.I("command [createDomain]")
out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
assert out == "Done", out
assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
log.I("command [createDomain] correctly executed")
log.I("Domain %s created" % (self.domain_name))
# New configurations creation for testing purpose
log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_1,self.domain_name))
log.I("command [createConfiguration]")
out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_1)
assert out == "Done", out
assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_1)
log.I("command [createConfiguration] correctly executed")
log.I("Configuration %s created for domain %s" % (self.conf_1,self.domain_name))
log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_2,self.domain_name))
log.I("command [createConfiguration]")
out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_2)
assert out == "Done", out
assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_2)
log.I("command [createConfiguration] correctly executed")
log.I("Configuration %s created for domain %s" % (self.conf_2,self.domain_name))
# Applying rules to configurations
log.I("Applying rules to configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
log.I("command [setRule]")
out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1,self.rule_1)
assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_1)
assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_1)
log.I("command [setRule] correctly executed")
log.I("rule correctly created for configuration %s" % (self.conf_1))
out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_2,self.rule_2)
assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_2)
assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_2)
log.I("command [setRule] correctly executed")
log.I("rule correctly created for configuration %s" % (self.conf_2))
# Clearing rule errors
log.I("Clearing a rule on domain %s to a non-existent configuration" % (self.domain_name))
log.I("command [clearRule]")
out, err = self.pfw.sendCmd("clearRule",self.domain_name,"Wrong_Config_Name")
assert err == None, "ERROR : command [clearRule] - Error while clearing rule on domain %s to a non-existent configuration" % (self.domain_name)
assert out != "Done", "ERROR : command [clearRule] - Error not detected while clearing rule on domain %s to a non-existent configuration" % (self.domain_name)
log.I("error correctly detected when clearing a rule to a non-existent configuration")
log.I("Clearing a rule on a non-existent domain")
log.I("command [clearRule]")
out, err = self.pfw.sendCmd("clearRule","Wrong_Domain_Name",self.conf_2)
assert err == None, "ERROR : command [clearRule] - Error while clearing rule on a non-existent domain"
assert out != "Done", "ERROR : command [clearRule] - Error not detected while clearing rule on a non-existent domain"
log.I("error correctly detected while clearing rule on a non-existent domain")
log.I("Clearing a rule with wrong parameters order")
log.I("command [clearRule]")
out, err = self.pfw.sendCmd("clearRule",self.conf_1,self.domain_name)
assert err == None, "ERROR : command [clearRule] - Error when clearing a rule with incorrect paramaters order"
assert out != "Done", "ERROR : command [clearRule] - Error not detected when clearing a rule with incorrect paramaters order"
log.I("error correctly detected when clearing a rule with incorrect paramaters order on domain %s and configuration %s" % (self.domain_name,self.conf_1))
#Checking that no rule has been cleared
out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_1)
assert out == self.rule_1, "FAIL : command [clearRule] - clearRule error has affected configuration %s" % (self.conf_1)
out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_2)
assert out == self.rule_2, "FAIL : command [clearRule] - clearRule error has affected configuration %s" % (self.conf_2)
log.I("command [ClearRule] correctly executed, no impact due to clearing errors")
log.I("no rule removed from configurations %s and %s on domain %s" % (self.conf_1,self.conf_2,self.domain_name))
# New domain deletion
log.I("Domain %s deletion" % (self.domain_name))
log.I("command [deleteDomain]")
out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
assert out == "Done", out
assert err == None, "ERROR : command [deleteDomain] - Error while delting domain %s" % (self.domain_name)
log.I("command [deleteDomain] correctly executed")
log.I("Domain %s deleted" % (self.domain_name))
def test_SetRule_Errors(self):
"""
Testing setRule errors
----------------------
Test case description :
~~~~~~~~~~~~~~~~~~~~~~~
- Setting rule on a non-existent configuration
- Setting rule on a non-existent domain
- Setting various incorrect format rules
Tested commands :
~~~~~~~~~~~~~~~~~
- [setRule] function
- [getRule] function
- [createDomain] function
- [createConfiguration] function
- [deleteDomain] function
Expected result :
~~~~~~~~~~~~~~~~~
- all errors are detected
- no new rule is created
"""
log.D(self.test_SetRule_Errors.__doc__)
# New domain creation for testing purpose
log.I("New domain creation for testing purpose : %s" % (self.domain_name))
log.I("command [createDomain]")
out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
assert out == "Done", out
assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
log.I("command [createDomain] correctly executed")
log.I("Domain %s created" % (self.domain_name))
# New configuration creation for testing purpose
log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_1,self.domain_name))
log.I("command [createConfiguration]")
out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_1)
assert out == "Done", out
assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_1)
log.I("command [createConfiguration] correctly executed")
log.I("Configuration %s created for domain %s" % (self.conf_1,self.domain_name))
# setRule :basic error cases
log.I("Applying a new rule on domain %s to a non-existent configuration" % (self.domain_name))
log.I("command [setRule]")
out, err = self.pfw.sendCmd("setRule",self.domain_name,"Wrong_Config_Name",self.rule_1)
assert err == None, "ERROR : command [setRule] - Error while setting rule on domain %s to a non-existent configuration" % (self.domain_name)
assert out != "Done", "ERROR : command [setRule] - Error not detected while setting rule on domain %s to a non-existent configuration" % (self.domain_name)
log.I("error correctly detected when creating a rule to a non-existent configuration")
log.I("Applying a new rule on a non-existent domain")
log.I("command [setRule]")
out, err = self.pfw.sendCmd("setRule","Wrong_Domain_Name",self.conf_1,self.rule_1)
assert err == None, "ERROR : command [setRule] - Error while setting rule on a non-existent domain"
assert out != "Done", "ERROR : command [setRule] - Error not detected while setting rule on a non-existent domain"
log.I("error correctly detected while setting rule on a non-existent domain")
log.I("Applying a new rule with incorrect format")
log.I("command [setRule]")
out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1,"Wrong_Rule_Format")
assert err == None, "ERROR : command [setRule] - Error when setting incorrect format rule"
assert out != "Done", "ERROR : command [setRule] - Error not detected when setting incorrect format rule"
log.I("error correctly detected when setting incorrect format rule on domain %s and configuration %s" % (self.domain_name,self.conf_1))
# setRule : various rules errors
log.I("Various rules errors setting :")
for index in range (self.rule_error_nbr):
log.I("Rule error number %s" % (str(index)))
rule_name = "".join(["self.rule_error_", "_", str(index)])
out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1, rule_name)
assert err == None, "ERROR : command [setRule] - Error when setting incorrect format rule %s" % (str(rule_name))
assert out != "Done", "ERROR : command [setRule] - Error not detected when setting incorrect format rule %s" % (str(rule_name))
log.I("error correctly detected when setting incorrect format rule on domain %s and configuration %s" % (self.domain_name,self.conf_1))
#Checking that no rule has been created
out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_1)
assert out == "<none>", "FAIL : command [setRule] - setRule not working for configuration %s" % (self.conf_1)
log.I("command [setRule] correctly executed, no impact due to setting errors")
log.I("no rule added to configurations %s on domain %s" % (self.conf_1,self.domain_name))
# New domain deletion
log.I("Domain %s deletion" % (self.domain_name))
log.I("command [deleteDomain]")
out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
assert out == "Done", out
assert err == None, "ERROR : command [deleteDomain] - Error while delting domain %s" % (self.domain_name)
log.I("command [deleteDomain] correctly executed")
log.I("Domain %s deleted" % (self.domain_name))
def test_GetRule_Errors(self):
"""
Testing getRule errors
----------------------
Test case description :
~~~~~~~~~~~~~~~~~~~~~~~
- Getting rule on a non-existent configuration
- Getting rule on a non-existent domain
- Getting rule with wrong parameters order
Tested commands :
~~~~~~~~~~~~~~~~~
- [getRule] function
- [setRule] function
- [clearRule] function
- [createDomain] function
- [createConfiguration] function
- [deleteDomain] function
Expected result :
~~~~~~~~~~~~~~~~~
- all errors are detected
"""
log.D(self.test_GetRule_Errors.__doc__)
# New domain creation for testing purpose
log.I("New domain creation for testing purpose : %s" % (self.domain_name))
log.I("command [createDomain]")
out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
assert out == "Done", out
assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
log.I("command [createDomain] correctly executed")
log.I("Domain %s created" % (self.domain_name))
# New configurations creation for testing purpose
log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_1,self.domain_name))
log.I("command [createConfiguration]")
out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_1)
assert out == "Done", out
assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_1)
log.I("command [createConfiguration] correctly executed")
log.I("Configuration %s created for domain %s" % (self.conf_1,self.domain_name))
log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_2,self.domain_name))
log.I("command [createConfiguration]")
out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_2)
assert out == "Done", out
assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_2)
log.I("command [createConfiguration] correctly executed")
log.I("Configuration %s created for domain %s" % (self.conf_2,self.domain_name))
# Applying rules to configurations
log.I("Applying rules to configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
log.I("command [setRule]")
out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1,self.rule_1)
assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_1)
assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_1)
log.I("command [setRule] correctly executed")
log.I("rule correctly created for configuration %s" % (self.conf_1))
out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_2,self.rule_2)
assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_2)
assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_2)
log.I("command [setRule] correctly executed")
log.I("rule correctly created for configuration %s" % (self.conf_2))
# Getting rule errors
log.I("Getting a rule on domain %s from a non-existent configuration" % (self.domain_name))
log.I("command [getRule]")
out, err = self.pfw.sendCmd("getRule",self.domain_name,"Wrong_Config_Name")
assert err == None, "ERROR : command [getRule] - Error when getting rule on domain %s from a non-existent configuration" % (self.domain_name)
assert out != "Done", "ERROR : command [getRule] - Error not detected while getting rule on domain %s from a non-existent configuration" % (self.domain_name)
log.I("error correctly detected when getting a rule from a non-existent configuration")
log.I("getting a rule from a non-existent domain")
log.I("command [getRule]")
out, err = self.pfw.sendCmd("getRule","Wrong_Domain_Name",self.conf_2)
assert err == None, "ERROR : command [getRule] - Error when getting rule from a non-existent domain"
assert out != "Done", "ERROR : command [getRule] - Error not detected while getting rule from a non-existent domain"
log.I("error correctly detected when getting rule from a non-existent domain")
log.I("getting a rule with wrong parameters order")
log.I("command [getRule]")
out, err = self.pfw.sendCmd("getRule",self.conf_1,self.domain_name)
assert err == None, "ERROR : command [getRule] - Error when getting a rule with incorrect paramaters order"
assert out != "Done", "ERROR : command [getRule] - Error not detected when getting a rule with incorrect paramaters order"
log.I("error correctly detected when getting a rule with incorrect paramaters order on domain %s and configuration %s" % (self.domain_name,self.conf_1))
# New domain deletion
log.I("Domain %s deletion" % (self.domain_name))
log.I("command [deleteDomain]")
out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
assert out == "Done", out
assert err == None, "ERROR : command [deleteDomain] - Error while delting domain %s" % (self.domain_name)
log.I("command [deleteDomain] correctly executed")
log.I("Domain %s deleted" % (self.domain_name))
def test_Nominal_Case(self):
"""
Testing nominal case
--------------------
Test case description :
~~~~~~~~~~~~~~~~~~~~~~~
- setting rules for configurations
- getting rules from configurations
- Clear created rules
Tested commands :
~~~~~~~~~~~~~~~~~
- [getRule] function
- [setRule] function
- [clearRule] function
- [createDomain] function
- [createConfiguration] function
- [deleteConfiguration] function
- [deleteDomain] function
Expected result :
~~~~~~~~~~~~~~~~~
- all operations succeed
"""
log.D(self.test_Nominal_Case.__doc__)
# New domain creation for testing purpose
log.I("New domain creation for testing purpose : %s" % (self.domain_name))
log.I("command [createDomain]")
out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
assert out == "Done", out
assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
log.I("command [createDomain] correctly executed")
log.I("Domain %s created" % (self.domain_name))
# New configurations creation for testing purpose
log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_1,self.domain_name))
log.I("command [createConfiguration]")
out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_1)
assert out == "Done", out
assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_1)
log.I("command [createConfiguration] correctly executed")
log.I("Configuration %s created for domain %s" % (self.conf_1,self.domain_name))
log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_2,self.domain_name))
log.I("command [createConfiguration]")
out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_2)
assert out == "Done", out
assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_2)
log.I("command [createConfiguration] correctly executed")
log.I("Configuration %s created for domain %s" % (self.conf_2,self.domain_name))
# Applying rules to configurations
log.I("Applying rules to configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
log.I("command [setRule]")
out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1,self.rule_1)
assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_1)
assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_1)
log.I("command [setRule] correctly executed")
log.I("rule correctly created for configuration %s" % (self.conf_1))
out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_2,self.rule_2)
assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_2)
assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_2)
log.I("command [setRule] correctly executed")
log.I("rule correctly created for configuration %s" % (self.conf_2))
# Checking rules recovered
log.I("Recovering rules for configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
log.I("command [getRule]")
out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_1)
assert err == None, "ERROR : command [getRule] - Error while setting rule to configurations %s" % (self.conf_1)
assert out == str(self.rule_1), "FAIL : command [getRule] - Error while recovering rule from configuration %s, incorrect value" % (self.conf_1)
log.I("command [getRule] correctly executed")
log.I("rule correctly recovered from configuration %s" % (self.conf_1))
out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_2)
assert err == None, "ERROR : command [getRule] - Error while setting rule to configurations %s" % (self.conf_2)
assert out == str(self.rule_2), "FAIL : command [getRule] - Error while recovering rule from configuration %s, incorrect value" % (self.conf_2)
log.I("command [getRule] correctly executed")
log.I("rule correctly recovered from configuration %s" % (self.conf_2))
# Clearing rules
log.I("Clear rules for configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
log.I("command [clearRule]")
out, err = self.pfw.sendCmd("clearRule",self.domain_name,self.conf_1)
assert err == None, "ERROR : command [clearRule] - Error on clearRule for configuration %s" % (self.conf_1)
assert out == "Done", "FAIL : command [clearRule] - Error on clearRule for configuration %s" % (self.conf_1)
out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_1)
assert out == "<none>", "ERROR : command [clearRule] - ClearRule not working for configuration %s" % (self.conf_1)
out, err = self.pfw.sendCmd("clearRule",self.domain_name,self.conf_2)
assert err == None, "ERROR : command [clearRule] - Error on clearRule for configuration %s" % (self.conf_2)
assert out == "Done", "FAIL : command [clearRule] - Error on clearRule for configuration %s" % (self.conf_2)
out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_2)
assert out == "<none>", "ERROR : command [clearRule] - ClearRule not working for configuration %s" % (self.conf_2)
log.I("command [clearRule] correctly executed")
log.I("ClearRule effective for configurations %s and %s" % (self.conf_1,self.conf_2))
# New domain deletion
log.I("Domain %s deletion" % (self.domain_name))
log.I("command [deleteDomain]")
out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
assert out == "Done", out
assert err == None, "ERROR : command [deleteDomain] - Error while delting domain %s" % (self.domain_name)
log.I("command [deleteDomain] correctly executed")
log.I("Domain %s deleted" % (self.domain_name))
|
