add expect_linter and fix issues it found

cce · cce · commit e77854515ba0 · 2024-09-04T14:46:52.000-04:00
diff --git a/test/e2e-go/cli/goal/expect/basicExpectTest.exp b/test/e2e-go/cli/goal/expect/basicExpectTest.exp
@@ -16,17 +16,19 @@ if { [catch {
     spawn echo "hello"
     expect {
         timeout { abort "\n Failed to see expected input hello" }
+        eof { abort "Ended without hello" }
         "^hello*" {close}
     }
 
     spawn echo "goodbye"
     expect {
         timeout { abort "Failed to see expected input goodbye" }
+        eof { abort "Ended without goodbye" }
         "^goodbye*" {close}
     }
 
     exit 0
 
 } EXCEPTION ] } {
    abort "ERROR in basic expect test: $EXCEPTION"
-}
+}
diff --git a/test/e2e-go/cli/goal/expect/expect_linter.py b/test/e2e-go/cli/goal/expect/expect_linter.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+import sys
+import argparse
+
+def check_expect_blocks(filename, verbose=False):
+    with open(filename, 'r') as f:
+        lines = f.readlines()
+
+    in_expect_block = False
+    brace_count = 0
+    block_start_line = None
+    current_block = []
+    expect_blocks = []
+
+    # Process each line, considering possible strings or comments
+    for line_num, line in enumerate(lines, start=1):
+        stripped_line = line.strip()
+
+        if not in_expect_block:
+            if "expect " in stripped_line and '{' in stripped_line:
+                in_expect_block = True
+                block_start_line = line_num
+                brace_count = stripped_line.count('{') - stripped_line.count('}')
+                current_block = [stripped_line]
+            elif stripped_line.startswith("#") or stripped_line.startswith("//"):
+                continue  # Ignore comment lines outside of expect blocks
+        else:
+            current_block.append(stripped_line)
+            brace_count += stripped_line.count('{') - stripped_line.count('}')
+
+            if brace_count == 0:
+                in_expect_block = False
+                expect_blocks.append((block_start_line, "\n".join(current_block)))
+                current_block = []
+
+    for block_start_line, block in expect_blocks:
+        if '#nolint:eof' in block:
+            if verbose:
+                print(f"{filename}:{block_start_line}: SKIP: 'nolint:eof' comment found, skipping")
+            continue
+
+        if 'eof' not in block:
+            # Check for only timeout condition
+            actions = block.count('}')
+            if block.count('timeout') == actions:
+                if verbose:
+                    print(f"{filename}:{block_start_line}: OK: only timeout action present")
+                continue
+
+            print(f"{filename}:{block_start_line}: Warning: missing 'eof' in expect block")
+        elif verbose:
+            print(f"{filename}:{block_start_line}: OK: expect block contains 'eof'")
+
+def main():
+    parser = argparse.ArgumentParser(description="Check for 'eof' in expect blocks of scripts.")
+    parser.add_argument('files', metavar='FILE', type=str, nargs='+', help='Files to check')
+    parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output')
+    args = parser.parse_args()
+
+    for fname in args.files:
+        check_expect_blocks(fname, args.verbose)
+
+if __name__ == "__main__":
+    main()
diff --git a/test/e2e-go/cli/goal/expect/goalCmdFlagsTest.exp b/test/e2e-go/cli/goal/expect/goalCmdFlagsTest.exp
@@ -5,7 +5,7 @@ log_user 1
 proc TestGoalCommandLineFlags { CMD EXPECTED_RE } {
     set PASSED 0
     eval spawn $CMD
-    expect {
+    expect { #nolint:eof checking PASSED catches no match
         timeout { puts "goal asset create timed out"; exit 1 }
         -re $EXPECTED_RE {set PASSED 1; close }
     }
diff --git a/test/e2e-go/cli/goal/expect/goalDryrunRestTest.exp b/test/e2e-go/cli/goal/expect/goalDryrunRestTest.exp
@@ -7,7 +7,7 @@ proc TestGoalDryrun { DRREQ_FILE TEST_PRIMARY_NODE_DIR } {
     set COST 0
     set PROGRAM_TYPE ""
     spawn goal clerk dryrun-remote -d $TEST_PRIMARY_NODE_DIR -D $DRREQ_FILE -v
-    expect {
+    expect { #nolint:eof checking PASSED catches no match
         timeout { ::AlgorandGoal::Abort "goal clerk dryrun-remote timeout" }
         "budget consumed:" {set COST 1; exp_continue}
         -re {(ApprovalProgram)} {set PROGRAM_TYPE $expect_out(1,string); exp_continue}
diff --git a/test/e2e-go/cli/goal/expect/goalExpectCommon.exp b/test/e2e-go/cli/goal/expect/goalExpectCommon.exp
@@ -234,12 +234,14 @@ proc ::AlgorandGoal::RestartNode { TEST_ALGO_DIR {SYSTEMD_MANAGED ""} } {
             expect {
                 timeout { close; ::AlgorandGoal::Abort "Did not receive appropriate message during node restart" }
                 "^The node was successfully stopped.*Algorand node successfully started!*" {puts "Node restarted successfully"; close}
+                eof { close; ::AlgorandGoal::Abort "Did not receive appropriate message before node restart eof" }
             }
         } else {
             spawn goal node restart -d $TEST_ALGO_DIR
             expect {
                 timeout { close; ::AlgorandGoal::Abort "Did not receive appropriate message during node restart" }
                 "^This node is using systemd and should be managed with systemctl*" { puts "Goal showed correct error message for systemd" ; close}
+                eof { close; ::AlgorandGoal::Abort "Did not receive appropriate message before node restart eof" }
             }
         }
     } EXCEPTION] } {
@@ -333,22 +335,27 @@ proc ::AlgorandGoal::CreateWallet { WALLET_NAME WALLET_PASSWORD TEST_PRIMARY_NOD
 
         expect {
             timeout {::AlgorandGoal::Abort "Timed out CreateWallet password"  }
+            eof {::AlgorandGoal::Abort "EOF CreateWallet password"  }
             "Please choose a password for wallet*" { send "$WALLET_PASSWORD\r" }
         }
         expect {
             timeout {::AlgorandGoal::Abort "Timed out CreateWallet confirmation"  }
+            eof {::AlgorandGoal::Abort "EOF CreateWallet confirmation"  }
             "Please confirm*" { send "$WALLET_PASSWORD\r"}
         }
         expect {
              timeout {::AlgorandGoal::Abort "Timed out CreateWallet see it now"  }
+             eof {::AlgorandGoal::Abort "EOF CreateWallet see it now"  }
              "Would you like to see it now? (Y/n):" { send "y\r" }
         }
         expect {
               timeout {::AlgorandGoal::Abort "Timed out CreateWallet keep info safe"  }
+              eof {::AlgorandGoal::Abort "EOF CreateWallet keep info safe"  }
               "Keep this information safe -- never share it with anyone!" {}
         }
         expect {
              timeout {::AlgorandGoal::Abort "Timed out CreateWallet pass phrase"  }
+             eof {::AlgorandGoal::Abort "EOF CreateWallet pass phrase"  }
              -re {([a-z ]+)} {set WALLET_PASS_PHRASE $expect_out(1,string); close;}
         }
     } EXCEPTION ] } {
@@ -364,6 +371,7 @@ proc ::AlgorandGoal::VerifyWallet { WALLET_NAME TEST_PRIMARY_NODE_DIR } {
         spawn goal wallet list -d $TEST_PRIMARY_NODE_DIR
         expect {
              timeout { ::AlgorandGoal::Abort "Timed out seeing expected input for spawn goal wallet list" }
+             eof { ::AlgorandGoal::Abort "EOF seeing expected input for spawn goal wallet list" }
              "*$WALLET_NAME*" {close}
         }
     } EXCEPTION ] } {
@@ -376,12 +384,14 @@ proc ::AlgorandGoal::RecoverWallet { NEW_WALLET_NAME WALLET_PASSPHRASE NEW_WALLE
     if { [catch {
         spawn goal wallet new -r $NEW_WALLET_NAME -d $TEST_PRIMARY_NODE_DIR
            expect {
-               timeout { puts "TIMEOUT"    }
+               timeout { ::AlgorandGoal::Abort "TIMEOUT"    }
+               eof { ::AlgorandGoal::Abort "EOF"    }
                {Please type your recovery mnemonic below, and hit return when you are done:*} { send "$WALLET_PASSPHRASE\r" }
             }
         for { set index 1}  {$index <= 5} {incr index} {
             expect {
-               timeout { puts "TIMEOUT"  }
+               timeout { ::AlgorandGoal::Abort "TIMEOUT"    }
+               eof { ::AlgorandGoal::Abort "EOF"    }
                {Please choose a password for wallet* } { send "$NEW_WALLET_PASSWORD\r"}
                {Please confirm the password:*} { send "$NEW_WALLET_PASSWORD\r"}
                {Creating wallet...*} {puts $expect_out(buffer) }
@@ -403,6 +413,7 @@ proc ::AlgorandGoal::CreateAccountForWallet { WALLET_NAME WALLET_PASSWORD TEST_P
         while 1 {
             expect {
                 timeout { break; ::AlgorandGoal::Abort "Timed out seeing new account created for wallet $WALLET_NAME" }
+                eof { break; ::AlgorandGoal::Abort "EOF seeing new account created for wallet $WALLET_NAME" }
                 "Please enter the password for wallet*" { send "$WALLET_PASSWORD\r" }
                  -re {Created new account with address ([a-zA-Z0-9]+)} {set ACCOUNT_ADDRESS $expect_out(1,string) ;close; break }
             }
@@ -422,6 +433,7 @@ proc ::AlgorandGoal::VerifyAccount { WALLET_NAME WALLET_PASSWORD ACCOUNT_ADDRESS
         while 1 {
             expect {
                 timeout {break; ::AlgorandGoal::Abort "Timed out seeing expected account: $ACCOUNT_ADDRESS"}
+                eof {break; ::AlgorandGoal::Abort "EOF seeing expected account: $ACCOUNT_ADDRESS"}
                 "Please enter the password for wallet*" { send "$WALLET_PASSWORD\r" }
                 -re {\t([A-Z0-9]+)\t([A-Z0-9]+)} {set RETURN_ACCOUNT_ADDRESS $expect_out(1,string); break  }
             }
@@ -487,6 +499,7 @@ proc ::AlgorandGoal::GetAccountRewards { WALLET_NAME ACCOUNT_ADDRESS TEST_PRIMAR
     spawn goal account rewards -w $WALLET_NAME -a $ACCOUNT_ADDRESS -d $TEST_PRIMARY_NODE_DIR
     expect {
         timeout { ::AlgorandGoal::Abort "Timed out retrieving account rewards for wallet $WALLET_NAME and account $ACCOUNT_ADDRESS"  }
+        eof { ::AlgorandGoal::Abort "EOF retrieving account rewards for wallet $WALLET_NAME and account $ACCOUNT_ADDRESS"  }
         -re {\d+} {set ACCOUNT_EARNINGS  $expect_out(0,string)}
     }
     puts "Wallet: $WALLET_NAME, Account: $ACCOUNT_ADDRESS, Rewards: $ACCOUNT_EARNINGS"
@@ -667,6 +680,7 @@ proc ::AlgorandGoal::LimitOrder {TEAL_DRIVER SWAP_N SWAP_D MIN_TRD OWNER FEE TIM
         spawn python $TEAL_DRIVER "limit-order" --swapn $SWAP_N --swapd $SWAP_D --mintrd $MIN_TRD --own $OWNER  --fee $FEE --timeout $TIME_OUT --asset $ASSET_ID
         expect {
             timeout { ::AlgorandGoal::Abort "Timed out limit order"  }
+            eof { ::AlgorandGoal::Abort "EOF limit order"  }
             -re {^.+$} { puts $limitf $expect_out(buffer); close $limitf; close }
         }
     } EXCEPTION ] } {
@@ -741,6 +755,7 @@ proc ::AlgorandGoal::RawSend { TXN_FILE TEST_PRIMARY_NODE_DIR } {
         spawn goal clerk rawsend -f $TXN_FILE -d $TEST_PRIMARY_NODE_DIR
         expect {
             timeout { close; ::AlgorandGoal::Abort "Timed out rawsend $TXN_FILE"  }
+            eof { close; ::AlgorandGoal::Abort "EOF rawsend $TXN_FILE"  }
             -re {Transaction ([A-Z0-9]{52}) committed} {set TRANSACTION_ID $expect_out(1,string); close }
 	        -re {Rejected transactions written to (.+rej)} {::AlgorandGoal::Abort "RawSend rejected."}
         }
@@ -809,6 +824,7 @@ proc ::AlgorandGoal::CheckNetworkAddressForCors { NET_ADDRESS } {
         spawn curl -X OPTIONS -H "Origin: http://algorand.com" --head $NET_ADDRESS
         expect {
             timeout { close; ::AlgorandGoal::Abort "Timeout failure in CheckNetworkAddressForCors" }
+            eof { close; ::AlgorandGoal::Abort "EOF in CheckNetworkAddressForCors" }
             "Access-Control-Allow-Origin" { puts "success" ; close  }
             eof {
                 return -code error "EOF without Access-Control-Allow-Origin in output"
@@ -826,6 +842,7 @@ proc ::AlgorandGoal::GetLedgerSupply { TEST_PRIMARY_NODE_DIR } {
         spawn goal ledger supply -d $TEST_PRIMARY_NODE_DIR
         expect {
             timeout { ::AlgorandGoal::Abort "Get Ledger Supply timed out"  }
+            eof { ::AlgorandGoal::Abort "Get Ledger Supply EOF"  }
             -re {Round: (\d+)} {set ROUND $expect_out(1,string); exp_continue }
             -re {Total Money: (\d+)} {set TOTAL_MONEY $expect_out(1,string); exp_continue }
             -re {Online Money: (\d+)} {set ONLINE_MONEY $expect_out(1,string) }
@@ -844,6 +861,7 @@ proc ::AlgorandGoal::CreateOneOfTwoMultisigForWallet { ADDRESS_1 ADDRESS_2 WALLE
         spawn goal account multisig new $ADDRESS_1 $ADDRESS_2 -T 1 -d $TEST_PRIMARY_NODE_DIR -w $WALLET_NAME
         expect {
             timeout { ::AlgorandGoal::Abort "Timed out creating a multisig account from $ADDRESS_1 and $ADDRESS_2"  }
+            eof { ::AlgorandGoal::Abort "EOF creating a multisig account from $ADDRESS_1 and $ADDRESS_2"  }
             "Please enter the password for wallet*" { send "$WALLET_PASSWORD\r" }
             -re {Created new account with address ([a-zA-Z0-9]+)} {
                     set MULTISIG_ADDRESS $expect_out(1,string);
@@ -862,6 +880,7 @@ proc ::AlgorandGoal::VerifyMultisigInfoForOneOfTwoMultisig { MULTISIG_ADDRESS AD
         spawn goal account multisig info --address $MULTISIG_ADDRESS -d $TEST_PRIMARY_NODE_DIR -w $WALLET_NAME
         expect {
             timeout { ::AlgorandGoal::Abort "Timed out querying info about multisig account $MULTISIG_ADDRESS"  }
+            eof { ::AlgorandGoal::Abort "EOF querying info about multisig account $MULTISIG_ADDRESS"  }
             -re {Version: (\d+)\s+Threshold: (\d+)\s+Public keys:\s+([a-zA-Z0-9]+)\s+([a-zA-Z0-9]+)\s+} {
                 set VERSION $expect_out(1,string);
                 set THRESHOLD $expect_out(2,string);
@@ -882,7 +901,11 @@ proc ::AlgorandGoal::VerifyMultisigInfoForOneOfTwoMultisig { MULTISIG_ADDRESS AD
 proc ::AlgorandGoal::DeleteMultisigAccount { MULTISIG_ADDRESS TEST_PRIMARY_NODE_DIR } {
     if { [ catch {
         spawn goal account multisig delete --address $MULTISIG_ADDRESS -d $TEST_PRIMARY_NODE_DIR
-        expect {*}
+        expect eof
+        set status [wait]
+        if {$status != 0} {
+            ::AlgorandGoal::Abort "DeleteMultisigAccount failed with exit code $status"
+        }
     } EXCEPTION ] } {
        ::AlgorandGoal::Abort "ERROR in DeleteMultisigAccount: $EXCEPTION"
     }
@@ -1049,6 +1072,7 @@ proc ::AlgorandGoal::Report { TEST_PRIMARY_NODE_DIR } {
         spawn goal report -d $TEST_PRIMARY_NODE_DIR
         expect {
             timeout { ::AlgorandGoal::Abort "goal report timed out"  }
+            eof { ::AlgorandGoal::Abort "goal report EOF"  }
             "source code available at https://github.com/algorand/go-algorand" {puts "goal -v ok"}
             -re {Genesis ID from genesis.json: *} {puts "genesis ID from genesis.json ok"}
             -re {Last committed block: (\d+)} {puts "status check ok"}
diff --git a/test/e2e-go/cli/goal/expect/goalTxValidityTest.exp b/test/e2e-go/cli/goal/expect/goalTxValidityTest.exp
@@ -32,6 +32,7 @@ proc TestLastValidInTx { CMD TX_FILE EXPECTED_LAST_VALID } {
     spawn goal clerk inspect $TX_FILE
     expect {
         timeout { ::AlgorandGoal::Abort "'goal clerk inspect' timed out" }
+        eof { ::AlgorandGoal::Abort "'goal clerk inspect' eof" }
         -re {"lv": (\d+)} {set PASSED 1; set LAST_VALID $expect_out(1,string); close }
     }
 
diff --git a/test/e2e-go/cli/goal/expect/limitOrderTest.exp b/test/e2e-go/cli/goal/expect/limitOrderTest.exp
@@ -123,7 +123,7 @@ if { [catch {
 
     puts "Generated Teal Source:"
     spawn cat $TEAL_SOURCE
-    expect {
+    expect { #nolint:eof not asserting expected output
 	    -re {^.+$} { close }
     }
 
diff --git a/test/e2e-go/cli/goal/expect/tealConsensusTest.exp b/test/e2e-go/cli/goal/expect/tealConsensusTest.exp
@@ -50,6 +50,7 @@ if { [catch {
     spawn goal clerk compile "$TEST_ROOT_DIR/small-sig.teal"
     expect {
         -re {[A-Z2-9]{58}} { set SMALL_SIG $expect_out(0,string) }
+        eof { ::AlgorandGoal::Abort $expect_out(buffer) }
         "\n" { ::AlgorandGoal::Abort $expect_out(buffer) }
     }
 
@@ -58,13 +59,15 @@ if { [catch {
     expect {
         -re {[A-Z2-9]{58}} { ::AlgorandGoal::Abort "hash" }
         -re {.*logicsig program size too large} { puts "bigsigcheck: pass" }
+        eof { ::AlgorandGoal::Abort $expect_out(buffer) }
         "\n" { ::AlgorandGoal::Abort $expect_out(buffer) }
     }
 
     teal "$TEST_ROOT_DIR/barely-fits-app.teal" 2 4090 1 "int 0\nbalance\npop\n"
     spawn goal clerk compile "$TEST_ROOT_DIR/barely-fits-app.teal"
     expect {
         -re {[A-Z2-9]{58}} { puts "hash $expect_out(0,string)" }
+        eof { ::AlgorandGoal::Abort $expect_out(buffer) }
         "\n" { ::AlgorandGoal::Abort $expect_out(buffer) }
     }
 
@@ -74,6 +77,7 @@ if { [catch {
     expect {
         -re {[A-Z2-9]{58}} { ::AlgorandGoal::Abort "hash" }
         -re {.*app program size too large} { puts "bigappcheck: pass" }
+        eof { ::AlgorandGoal::Abort $expect_out(buffer) }
         "\n" { ::AlgorandGoal::Abort $expect_out(buffer) }
     }
 
@@ -84,6 +88,7 @@ if { [catch {
         " - pass -" { puts "small-sig dryrun pass" }
         "REJECT" { ::AlgorandGoal::Abort $expect_out(buffer) }
         "static cost budget" { ::AlgorandGoal::Abort $expect_out(buffer) }
+        eof { ::AlgorandGoal::Abort $expect_out(buffer) }
     }
 
     teal "$TEST_ROOT_DIR/slow-sig.teal" 2 1 20001
@@ -94,6 +99,7 @@ if { [catch {
         "dynamic cost budget" { puts "slow-sig dryrun pass" }
         " - pass -" { ::AlgorandGoal::Abort $expect_out(buffer) }
         "REJECT" { ::AlgorandGoal::Abort $expect_out(buffer) }
+        eof { ::AlgorandGoal::Abort $expect_out(buffer) }
     }
 
     # Shutdown the network
diff --git a/test/e2e-go/cli/goal/expect/testInfraTest.exp b/test/e2e-go/cli/goal/expect/testInfraTest.exp
@@ -58,6 +58,7 @@ proc checkProcessReturnedCodeTest {} {
 	44 {
 	    close
 	}
+        eof { puts "expected output not 44"; exit 1 }
     }
     lassign [::AlgorandGoal::CheckProcessReturnedCode 0] response OS_CODE ERR_CODE KILLED KILL_SIGNAL EXP
     if {$response != 0} {
@@ -72,6 +73,7 @@ proc checkProcessReturnedCodeTest {} {
 	44 {
 	    puts "not closing"
 	}
+        eof { puts "expected output not 44"; exit 1 }
     }
     lassign [::AlgorandGoal::CheckProcessReturnedCode 0] response OS_CODE ERR_CODE KILLED KILL_SIGNAL EXP
     if {$KILLED != "CHILDKILLED" || $KILL_SIGNAL != "SIGSEGV" || $EXP != "segmentation violation"} {

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ log_user 1`
`5`	`5`	`proc TestGoalCommandLineFlags { CMD EXPECTED_RE } {`
`6`	`6`	`set PASSED 0`
`7`	`7`	`eval spawn $CMD`
`8`		`- expect {`
	`8`	`+ expect { #nolint:eof checking PASSED catches no match`
`9`	`9`	`timeout { puts "goal asset create timed out"; exit 1 }`
`10`	`10`	`-re $EXPECTED_RE {set PASSED 1; close }`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ proc TestLastValidInTx { CMD TX_FILE EXPECTED_LAST_VALID } {`
`32`	`32`	`spawn goal clerk inspect $TX_FILE`
`33`	`33`	`expect {`
`34`	`34`	`timeout { ::AlgorandGoal::Abort "'goal clerk inspect' timed out" }`
	`35`	`+ eof { ::AlgorandGoal::Abort "'goal clerk inspect' eof" }`
`35`	`36`	`-re {"lv": (\d+)} {set PASSED 1; set LAST_VALID $expect_out(1,string); close }`
`36`	`37`	`}`
`37`	`38`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ if { [catch {`
`123`	`123`
`124`	`124`	`puts "Generated Teal Source:"`
`125`	`125`	`spawn cat $TEAL_SOURCE`
`126`		`- expect {`
	`126`	`+ expect { #nolint:eof not asserting expected output`
`127`	`127`	`-re {^.+$} { close }`
`128`	`128`	`}`
`129`	`129`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ proc checkProcessReturnedCodeTest {} {`
`58`	`58`	`44 {`
`59`	`59`	`close`
`60`	`60`	`}`
	`61`	`+ eof { puts "expected output not 44"; exit 1 }`
`61`	`62`	`}`
`62`	`63`	`lassign [::AlgorandGoal::CheckProcessReturnedCode 0] response OS_CODE ERR_CODE KILLED KILL_SIGNAL EXP`
`63`	`64`	`if {$response != 0} {`
`@@ -72,6 +73,7 @@ proc checkProcessReturnedCodeTest {} {`
`72`	`73`	`44 {`
`73`	`74`	`puts "not closing"`
`74`	`75`	`}`
	`76`	`+ eof { puts "expected output not 44"; exit 1 }`
`75`	`77`	`}`
`76`	`78`	`lassign [::AlgorandGoal::CheckProcessReturnedCode 0] response OS_CODE ERR_CODE KILLED KILL_SIGNAL EXP`
`77`	`79`	`if {$KILLED != "CHILDKILLED" \|\| $KILL_SIGNAL != "SIGSEGV" \|\| $EXP != "segmentation violation"} {`