holado 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

test_holado/features/NonReg/holado_python/iterable.feature

@@ -0,0 +1,61 @@
+@testing_solution
+@python
+Feature: Test python iterable steps
+
+    @is_in
+    Scenario: Get if an element is in an iterable
+
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+
+        Given LIST_STR = ['v1', 'v2']
+        Given STR_IN = 'v1'
+        Given STR_NOT_IN = 'x'
+
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        Given IS_IN = is 'v1' in ['v1', 'v2']
+        Then IS_IN == True
+        
+        Given IS_IN = is 'xx' in ['v1', 'v2']
+        Then IS_IN == False
+        
+        
+        Given IS_IN = is STR_IN in LIST_STR
+        Then IS_IN == True
+        
+        Given IS_IN = is STR_NOT_IN in LIST_STR
+        Then IS_IN == False
+        
+        
+    @then_is_in
+    Scenario: Verify that element is in an iterable
+
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+
+        Given LIST_STR = ['v1', 'v2']
+        Given STR_IN = 'v1'
+        Given STR_NOT_IN = 'x'
+
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        Then 'v1' is in ['v1', 'v2']
+        Then 'xx' is not in ['v1', 'v2']
+        
+        Then STR_IN is in LIST_STR
+        Then STR_NOT_IN is not in LIST_STR
+        
+        Given next step shall fail on exception matching 'VerifyException\(Value is in iterable:.*value: v1.*iterable: \['v1', 'v2'\]\)'
+        Then STR_IN is not in LIST_STR
+        
+        Given next step shall fail on exception matching 'VerifyException\(Value is not in iterable:.*value: x.*iterable: \['v1', 'v2'\]\)'
+        Then STR_NOT_IN is in LIST_STR
+        
+
+
+
+
+

test_holado/features/NonReg/holado_python/standard_library/socket.feature

@@ -0,0 +1,101 @@
+@testing_solution
+@python
+@socket
+Feature: Test python socket steps
+
+    @blocking_socket
+    Scenario: Server and client with blocking connections
+
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+        
+        Given PORT = first available anonymous port
+        Given SERVER = new echo TCP socket server
+            | Name   | Value       |
+            | 'host' | '127.0.0.1' |
+            | 'port' | PORT        |
+        
+        Given CLIENT = new TCP socket client
+            | Name       | Value       |
+            | 'host'     | '127.0.0.1' |
+            | 'port'     | PORT        |
+        
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        # Start echo server
+        When start (socket server: SERVER)
+        
+        # Write data and verify result is identical
+        When write b'\x01\x02' (socket: CLIENT)
+        When DATA = read (socket: CLIENT)
+        Then DATA == b'\x01\x02'
+        
+        When write b'\x11\x21' (socket: CLIENT)
+        When DATA = read (socket: CLIENT)
+        Then DATA == b'\x11\x21'
+        
+        # Stop server & client
+        #When stop (socket server: SERVER)
+
+
+
+    @message_socket
+    Scenario: Echo server and message client with non blocking connection
+
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+        
+        # Use echo server with a blocking connection
+        Given PORT = first available anonymous port
+        Given SERVER = new echo TCP socket server
+            | Name   | Value       |
+            | 'host' | '127.0.0.1' |
+            | 'port' | PORT        |
+        
+        # Create a message client
+        Given CLIENT = new message TCP socket client
+            | Name        | Value       |
+            | 'host'      | '127.0.0.1' |
+            | 'port'      | PORT        |
+            | 'separator' | b'\n'       |
+        
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        # Start echo server & message client
+        When start (socket server: SERVER)
+        When start (socket client: CLIENT)
+        
+        # Write data and verify result is identical
+        When write message b'\x01\x02' (socket: CLIENT)
+        When write message b'\x11\x21' (socket: CLIENT)
+        
+        # Verify received messages
+        When wait socket CLIENT stops to receive messages (window: 0.1 s)
+        When MESSAGES = received messages (socket: CLIENT)
+        Then MESSAGES is list
+            | b'\x01\x02' |
+            | b'\x11\x21' |
+        
+        When MESSAGES_2 = received messages (socket: CLIENT)
+        Then MESSAGES_2 == MESSAGES
+        
+        # Verify pop messages functionality
+        When MSG_1 = read message (socket: CLIENT)
+        Then MSG_1 == b'\x01\x02'
+        When MESSAGES_3 = received messages (socket: CLIENT)
+        Then MESSAGES_3 is list
+            | b'\x11\x21' |
+
+        When MSG_2 = read message (socket: CLIENT)
+        Then MSG_2 == b'\x11\x21'
+        When MESSAGES_4 = received messages (socket: CLIENT)
+        Then MESSAGES_4 is empty list
+        
+        # Stop server & client
+        #When stop (socket server: SERVER)
+        When stop (socket client: CLIENT)
+
+
+

test_holado/features/NonReg/holado_python/standard_library/socket_with_ssl.feature

@@ -0,0 +1,180 @@
+@testing_solution
+@python
+@socket
+@ssl
+Feature: Test python socket steps with ssl
+
+    @blocking_socket
+    Scenario: Server and client with blocking connections
+
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+        
+        # Get files of a self-signed certificate
+        Given CERTFILE_PATH = certfile path for localhost
+        Given KEYFILE_PATH = keyfile path for localhost
+        
+        # Use echo server with a blocking connection
+        Given PORT = first available anonymous port
+        Given SERVER = new echo TCP socket server
+            | Name                                   | Value         |
+            | 'host'                                 | 'localhost'   |
+            | 'port'                                 | PORT          |
+            | 'ssl.activate'                         | True          |
+            | 'ssl.context.ciphers'                  | 'SHA256'      |
+            | 'ssl.context.load_cert_chain.certfile' | CERTFILE_PATH |
+            | 'ssl.context.load_cert_chain.keyfile'  | KEYFILE_PATH  |
+        
+        # Create a TCP client with a blocking connection
+        Given CLIENT = new TCP socket client
+            | Name                                       | Value         |
+            | 'host'                                     | 'localhost'   |
+            | 'port'                                     | PORT          |
+            | 'ssl.activate'                             | True          |
+            | 'ssl.context.check_hostname'               | True          |
+            | 'ssl.context.load_verify_locations.cafile' | CERTFILE_PATH |
+        
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        # Start echo server
+        When start (socket server: SERVER)
+        
+        # Write data and verify result is identical
+        When write b'\x01\x02' (socket: CLIENT)
+        When DATA = read (socket: CLIENT)
+        Then DATA == b'\x01\x02'
+        
+        When write b'\x11\x21' (socket: CLIENT)
+        When DATA = read (socket: CLIENT)
+        Then DATA == b'\x11\x21'
+        
+        # Stop server
+        #When stop (socket server: SERVER)
+
+
+    @non_blocking_socket
+    Scenario: Server and client with non blocking connection
+
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+        
+        # Get files of a self-signed certificate
+        Given CERTFILE_PATH = certfile path for localhost
+        Given KEYFILE_PATH = keyfile path for localhost
+        
+        # Use echo server with a blocking connection
+        Given PORT = first available anonymous port
+        Given SERVER = new echo TCP socket server
+            | Name                                   | Value         |
+            | 'host'                                 | 'localhost'   |
+            | 'port'                                 | PORT          |
+            | 'ssl.activate'                         | True          |
+            | 'ssl.context.ciphers'                  | 'SHA256'      |
+            | 'ssl.context.load_cert_chain.certfile' | CERTFILE_PATH |
+            | 'ssl.context.load_cert_chain.keyfile'  | KEYFILE_PATH  |
+        
+        # Create a TCP client with a blocking connection
+        Given CLIENT = new TCP socket client
+            | Name                                       | Value         |
+            | 'host'                                     | 'localhost'   |
+            | 'port'                                     | PORT          |
+            | 'blocking'                                 | False         |
+            | 'ssl.activate'                             | True          |
+            | 'ssl.context.check_hostname'               | True          |
+            | 'ssl.context.load_verify_locations.cafile' | CERTFILE_PATH |
+        
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        # Start echo server & client
+        When start (socket server: SERVER)
+        When start (socket client: CLIENT)
+        
+        # Write data and verify result is identical
+        When write b'\x01\x02' (socket: CLIENT)
+        When wait socket CLIENT stops to receive data (window: 0.1 s)
+        When DATA = read (socket: CLIENT)
+        Then DATA == b'\x01\x02'
+        
+        When write b'\x11\x21' (socket: CLIENT)
+        When wait socket CLIENT stops to receive data (window: 0.1 s)
+        When DATA = read (socket: CLIENT)
+        Then DATA == b'\x11\x21'
+        
+        # Stop server & client
+        #When stop (socket server: SERVER)
+        When stop (socket client: CLIENT)
+
+
+
+    @message_socket
+    Scenario: Echo server and message client (with underlying non blocking connection)
+
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+        
+        # Get files of a self-signed certificate
+        Given CERTFILE_PATH = certfile path for localhost
+        Given KEYFILE_PATH = keyfile path for localhost
+        
+        # Use echo server with a blocking connection
+        Given PORT = first available anonymous port
+        Given SERVER = new echo TCP socket server
+            | Name                                   | Value         |
+            | 'host'                                 | 'localhost'   |
+            | 'port'                                 | PORT          |
+            | 'ssl.activate'                         | True          |
+            | 'ssl.context.ciphers'                  | 'SHA256'      |
+            | 'ssl.context.load_cert_chain.certfile' | CERTFILE_PATH |
+            | 'ssl.context.load_cert_chain.keyfile'  | KEYFILE_PATH  |
+        
+        # Create a message client
+        Given CLIENT = new message TCP socket client
+            | Name                                       | Value         |
+            | 'host'                                     | 'localhost'   |
+            | 'port'                                     | PORT          |
+            | 'separator'                                | b'\n'         |
+            | 'ssl.activate'                             | True          |
+            | 'ssl.context.check_hostname'               | True          |
+            | 'ssl.context.load_verify_locations.cafile' | CERTFILE_PATH |
+        
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        # Start echo server & message client
+        When start (socket server: SERVER)
+        When start (socket client: CLIENT)
+        
+        # Write data and verify result is identical
+        When write message b'\x01\x02' (socket: CLIENT)
+        When write message b'\x11\x21' (socket: CLIENT)
+        
+        # Verify received messages
+        When wait socket CLIENT stops to receive messages (window: 0.1 s)
+        When MESSAGES = received messages (socket: CLIENT)
+        Then MESSAGES is list
+            | b'\x01\x02' |
+            | b'\x11\x21' |
+        
+        When MESSAGES_2 = received messages (socket: CLIENT)
+        Then MESSAGES_2 == MESSAGES
+        
+        # Verify pop messages functionality
+        When MSG_1 = read message (socket: CLIENT)
+        Then MSG_1 == b'\x01\x02'
+        When MESSAGES_3 = received messages (socket: CLIENT)
+        Then MESSAGES_3 is list
+            | b'\x11\x21' |
+
+        When MSG_2 = read message (socket: CLIENT)
+        Then MSG_2 == b'\x11\x21'
+        When MESSAGES_4 = received messages (socket: CLIENT)
+        Then MESSAGES_4 is empty list
+        
+        # Stop server & client
+        #When stop (socket server: SERVER)
+        When stop (socket client: CLIENT)
+
+
+

test_holado/features/NonReg/holado_scripting/common/tools/dynamic_text_manager.feature

@@ -0,0 +1,18 @@
+@testing_solution
+@DynamicTextManager
+Feature: Features related to DynamicTextManager
+
+    Scenario: dynamic string compare
+
+        Given VAR = 'test'%
+
+        Then VAR == 'test'%
+        #Then VAR == '${MatchPattern(test[a-zA-Z0-9]{6})}'
+        Then VAR != 'test'
+        Then VAR < 'tesu'
+        
+        Then 'test'% == VAR
+        #Then '${MatchPattern(test[a-zA-Z0-9]{6})}' == VAR
+        Then 'test' != VAR
+        Then 'test' < VAR
+        

test_holado/features/NonReg/holado_scripting/common/tools/expression_evaluator.feature

@@ -0,0 +1,185 @@
+@testing_solution
+@expression_evaluator
+Feature: Features related to expression_evaluator
+
+    Scenario: Expressions in tables
+
+        Given VAL_5 = 5
+        Given VAL_9 = 9
+        Given VAL_10 = 10
+        Given VAL_11 = 11
+        Given VAL_20 = 20
+        
+        #Given TABLE = table
+            #| Name      | Value   |
+            #| 'name'    | VAL     |
+            #| 'name +'  | VAL + 1 |
+            #| 'name -'  | VAL - 1 |
+        Given TABLE = convert json '{"name": 10, "name +": 11, "name -": 9}' to name/value table with names uncollapsed
+
+        Then table TABLE is
+            | Name      | Value |
+            | 'name'    | 10    |
+            | 'name +'  | 11    |
+            | 'name -'  | 9     |
+
+        Then table TABLE is
+            | Name      | Value       |
+            | 'name'    | VAL_10      |
+            | 'name +'  | ${VAL_10} + 1  |
+            | 'name -'  | ${VAL_10} - 1  |
+
+        Then table TABLE is
+            | Name      | Value       |
+            | 'name'    | ${VAL_9} + 1   |
+            | 'name +'  | ${VAL_9} + 2   |
+            | 'name -'  | ${VAL_11} - 2  |
+
+        Then table TABLE is
+            | Name      | Value         |
+            | 'name'    | ${VAL_20} / 2    |
+            | 'name +'  | ${VAL_5} * 2 + 1 |
+            | 'name -'  | ${VAL_5} * 2 - 1 |
+            
+            
+    @expression_assignment
+    Scenario: Expressions in assignment
+
+        Given VAL = ${int(32)}
+        Then VAL == 32
+
+        Given VAL = ${32}
+        Then VAL == 32
+
+        Given VAL = ${128} >> 2
+        Then VAL == 32
+        
+        Given X = 128
+        Given VAL = ${X} >> 2 if ${X} >= 64 else ${X} >> 1
+        Then VAL == 32
+        
+        Given X = 32
+        Given VAL = ${X} >> 2 if ${X} >= 64 else ${X} >> 1
+        Then VAL == 16
+        
+        Given X = 32
+        Given VAL = ${X} + 1
+        Then VAL == 33
+        
+        Given LIST = [1, 2, 3]
+        Given INDEX = 1
+        Given VAL = ${LIST[${INDEX}]}
+        Then VAL == 2
+        
+        Given LIST_STR = '[1, 2, 3]'
+        Given LIST = ${list(${LIST_STR})}
+        Given INDEX = 1
+        Given VAL = ${LIST[${INDEX}]}
+        Then VAL == 2
+        
+    @timedelta
+    Scenario: timedelta
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+
+        Given DT_1 = datetime now
+        Given DT_2 = DT_1 + 3 seconds
+        Given EXPECTED = ${datetime.timedelta(seconds=3)}
+        
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        Given DELTA = ${DT_2} - ${DT_1}
+        Then DELTA == EXPECTED
+
+    Scenario: Expressions in for and if
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+
+        Given VAL_5 = 5
+        Given VAL_9 = 9
+        Given VAL_10 = 10
+        Given VAL_11 = 11
+        Given VAL_20 = 20
+        
+        Given TABLE = convert json '{"name": 10, "name +": 11, "name -": 9}' to name/value table with names uncollapsed
+        
+        Given end preconditions
+        ### PRECONDITIONS - END
+
+        Given for N in range(0,2):
+            Given VAL_5_1 = ${VAL_5} - 1
+            Given VAL_5_N = ${VAL_5} - ${N}
+            
+            Then VAL_5_1 == 4
+            Then table TABLE is
+                | Name      | Value       |
+                | 'name'    | VAL_10      |
+                | 'name +'  | ${VAL_10} + 1  |
+                | 'name -'  | ${VAL_10} - 1  |
+                
+            Given if ${N} == 0:
+                Then VAL_5_N == 5
+                
+                Then table TABLE is
+                    | Name      | Value       |
+                    | 'name'    | VAL_10      |
+                    | 'name +'  | ${VAL_10} + 1  |
+                    | 'name -'  | ${VAL_10} - 1  |
+            Given else:
+                Then VAL_5_N == 4
+                
+                Then table TABLE is
+                    | Name      | Value       |
+                    | 'name'    | VAL_10      |
+                    | 'name +'  | ${VAL_10} + ${N} |
+                    | 'name -'  | ${VAL_10} - ${N} |
+            Given end if
+        Given end for
+        
+    
+    @expression_if
+    Scenario: Expressions in if
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+
+        Given VAL_5 = 5
+        Given VAL_9 = 9
+        Given VAL_10 = 10
+        Given VAL_11 = 11
+        Given VAL_20 = 20
+        
+        Given TABLE = convert json '{"name": 10, "name +": 11, "name -": 9}' to name/value table with names uncollapsed
+        
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        Given INDEX = 2
+        Given N_2 = 5
+        Given if ${N_${INDEX}} == 3:
+            Given RESULT = 13
+        Given else if ${N_${INDEX}} == 5:
+            Given RESULT = 15
+        Given else:
+            Given RESULT = 10
+        Given end if
+        
+        Then RESULT == 15
+        
+    @string_evaluation
+    Scenario: String evaluation
+        Given INDEX = 3
+        Given TEXT = 'toto.tata[${INDEX}]'
+        Then TEXT == 'toto.tata[3]'
+        
+        Given TABLE = table with header
+            | Name                  | Value |
+            | 'toto.tata[${INDEX}]' | 5     |
+        Then table TABLE is
+            | Name           | Value |
+            | 'toto.tata[3]' | 5     |
+            
+        Given TOTO = 'toto'
+        Given TEXT = 'TOTO.tata[${INDEX}]'
+        Then TEXT == 'TOTO.tata[3]'
+        

test_holado/features/NonReg/holado_scripting/common/tools/variable_manager.feature

@@ -0,0 +1,71 @@
+@testing_solution
+@VariableManager
+Feature: Features related to VariableManager
+
+    Scenario: basic variable use
+        Given VAR1 = 'test'
+        Given VAR2 = VAR1
+        Then VAR1 == 'test'
+        Then VAR2 == 'test'
+        Then VAR1 == VAR2
+
+    Scenario: string compare
+        Then 'test' == 'test'
+        Then 'test' != 'test1'
+        Then 'test' <= 'test'
+        Then 'test' <= 'tesu'
+        Then 'test' < 'tesu'
+        
+        Given VAR = 'test'
+        
+        Then VAR == 'test'
+        Then VAR != 'test1'
+        Then VAR <= 'test'
+        Then VAR <= 'tesu'
+        Then VAR < 'tesu'
+        
+        Then 'test' == VAR
+        Then 'test1' != VAR
+        Then 'test' <= VAR
+        Then 'tess' <= VAR
+        Then 'tess' < VAR
+        Then 'tesu' > VAR
+      
+    @list
+    Scenario: List of ids
+        Given LISTVAR = list
+            | 1    |
+            | 0    |
+            | 5    |
+            
+        Then [1, 0, 5] == ${LISTVAR}
+        Then '[1, 0, 5]' != ${LISTVAR}
+        Then '[1, 0, 5]' == '${LISTVAR}'
+        
+        Then '[1, 0, 5]' == str(${LISTVAR})
+        # In next expression, after having casted to str, ${} makes an evaluation of obtained string, thus result of ${str(LISTVAR)} is a list
+        Then '[1, 0, 5]' != ${str(LISTVAR)}
+        Then [1, 0, 5] == ${str(LISTVAR)}
+    
+    Scenario: Comprehension expression
+        Given LISTVAR = list(range(0,5))
+        Then LISTVAR == [0, 1, 2, 3, 4]
+        
+        Given RES = list of ${X} * 2 for X in LISTVAR
+        Then RES == [0, 2, 4, 6, 8]
+        
+    Scenario: Sorted
+        Given VAL = [2,4,0,3,1]
+        Given RES = sorted VAL
+        Then RES == [0, 1, 2, 3, 4]
+        
+        Given VAL = [(0,2),(1,4),(2,0),(3,3),(4,1)]
+        Given RES = sorted VAL by x: x[1]
+        Then RES == [(2,0),(4,1),(0,2),(3,3),(1,4)]
+        
+    Scenario: Call python builtin functions
+        Given VAL_FLOAT = 2.568
+        When VAL_INT = round(${VAL_FLOAT})
+        Then VAL_INT == 3
+        
+        

test_holado/features/NonReg/holado_scripting/text/interpreter/interpreter.error.feature

@@ -0,0 +1,21 @@
+@testing_solution
+@TextInterpreter
+@error
+Feature: Features related to TextInterpreter
+
+    @HexToBytes
+    Scenario: function HexToBytes
+
+        Given HEX = '\x2d569F'
+        Given next step shall fail on exception matching 'Source \[-569F\] \(type: str\) is not an hexadecimal string'
+        Given VALUE_1 = ${HexToBytes(HEX)}
+
+        Given TABLE = table with header
+            | Name   | Value              |
+            | 'test' | ${HexToBytes(HEX)} |
+        Given next step shall fail on exception matching 'Source \[-569F\] \(type: str\) is not an hexadecimal string'
+        Then table TABLE is
+            | Name   | Value  |
+            | 'test' | 'PIPO' |
+
+