11// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
22// SPDX-License-Identifier: Apache-2.0
33
4- //! Portable phase-1 CLI conformance scenario .
4+ //! Portable smoke conformance scenarios .
55
6+ use std:: ffi:: OsString ;
67use std:: time:: { Duration , Instant } ;
78
89use crate :: { OpenShellRunner , STATUS_TIMEOUT , Scenario , ScenarioFuture } ;
@@ -31,15 +32,40 @@ struct SandboxListPage {
3132/// Certify status -> create -> list Ready -> exec -> delete -> list empty.
3233pub const SMOKE_SCENARIO : Scenario = Scenario {
3334 name : "smoke" ,
34- description : "Create, inspect, execute in, and delete a base sandbox ." ,
35+ description : "Run the control-plane and exec smoke scenarios ." ,
3536 run : run_smoke,
3637} ;
3738
39+ /// Certify status -> create -> get/list Ready -> delete -> list empty.
40+ pub const SMOKE_CONTROL_PLANE_SCENARIO : Scenario = Scenario {
41+ name : "smoke-control-plane" ,
42+ description : "Create, inspect, and delete a sandbox without using sandbox exec." ,
43+ run : run_smoke_control_plane,
44+ } ;
45+
46+ /// Certify create -> exec -> delete for drivers that support interactive exec.
47+ pub const SMOKE_EXEC_SCENARIO : Scenario = Scenario {
48+ name : "smoke-exec" ,
49+ description : "Create a sandbox, execute a command in it, and delete it." ,
50+ run : run_smoke_exec,
51+ } ;
52+
3853fn run_smoke ( runner : & mut OpenShellRunner ) -> ScenarioFuture < ' _ > {
39- Box :: pin ( async move { run_smoke_inner ( runner) . await } )
54+ Box :: pin ( async move {
55+ run_smoke_control_plane_inner ( runner) . await ?;
56+ run_smoke_exec_inner ( runner) . await
57+ } )
58+ }
59+
60+ fn run_smoke_control_plane ( runner : & mut OpenShellRunner ) -> ScenarioFuture < ' _ > {
61+ Box :: pin ( async move { run_smoke_control_plane_inner ( runner) . await } )
4062}
4163
42- async fn run_smoke_inner ( runner : & mut OpenShellRunner ) -> Result < ( ) , String > {
64+ fn run_smoke_exec ( runner : & mut OpenShellRunner ) -> ScenarioFuture < ' _ > {
65+ Box :: pin ( async move { run_smoke_exec_inner ( runner) . await } )
66+ }
67+
68+ async fn run_smoke_control_plane_inner ( runner : & mut OpenShellRunner ) -> Result < ( ) , String > {
4369 let status = runner
4470 . step ( "status" )
4571 . description ( "openshell status succeeds" )
@@ -49,43 +75,18 @@ async fn run_smoke_inner(runner: &mut OpenShellRunner) -> Result<(), String> {
4975 . map_err ( |error| error. to_string ( ) ) ?;
5076 status. require_success ( ) ?;
5177
52- let sandbox_name = format ! ( "ct-{}-01" , runner. id( ) ) ;
53- runner. track_sandbox ( & sandbox_name) ;
54- let create = runner
55- . step ( "create" )
56- . description ( "sandbox creation succeeds" )
57- . with_timeout ( CREATE_TIMEOUT )
58- . run ( & [ "sandbox" , "create" , "--name" , & sandbox_name, "--detach" ] )
59- . await
60- . map_err ( |error| error. to_string ( ) ) ?;
61- create. require_success ( ) ?;
62-
63- let get = runner
64- . step ( "get-ready" )
65- . description ( format ! ( "sandbox '{sandbox_name}' can be retrieved" ) )
66- . with_timeout ( LIST_ATTEMPT_TIMEOUT )
67- . run ( & [ "sandbox" , "get" , & sandbox_name, "--output" , "json" ] )
68- . await
69- . map_err ( |error| error. to_string ( ) ) ?;
70- get. require_success ( ) ?;
78+ let sandbox_name = format ! ( "ct-{}-cp" , runner. id( ) ) ;
79+ create_sandbox ( runner, & sandbox_name, "create" ) . await ?;
80+ check_sandbox_ready ( runner, & sandbox_name) . await ?;
81+ check_sandbox_listed ( runner, & sandbox_name) . await ?;
7182
72- let sandbox = get
73- . json :: < SandboxListEntry > ( )
74- . map_err ( |error| error. to_string ( ) ) ?;
75- if sandbox. name != sandbox_name {
76- return Err ( format ! (
77- "sandbox get returned {:?}; expected sandbox '{sandbox_name}'" ,
78- sandbox. name
79- ) ) ;
80- }
81- if sandbox. phase != "Ready" {
82- return Err ( format ! (
83- "sandbox '{sandbox_name}' is in phase {:?}; expected Ready" ,
84- sandbox. phase
85- ) ) ;
86- }
83+ delete_sandbox ( runner, & sandbox_name, "delete" ) . await
84+ }
8785
88- check_sandbox_listed ( runner, & sandbox_name) . await ?;
86+ async fn run_smoke_exec_inner ( runner : & mut OpenShellRunner ) -> Result < ( ) , String > {
87+ let sandbox_name = format ! ( "ct-{}-ex" , runner. id( ) ) ;
88+ create_sandbox ( runner, & sandbox_name, "create" ) . await ?;
89+ check_sandbox_ready ( runner, & sandbox_name) . await ?;
8990
9091 let marker = format ! ( "openshell-conformance-{}" , runner. id( ) ) ;
9192 let exec = runner
@@ -110,17 +111,103 @@ async fn run_smoke_inner(runner: &mut OpenShellRunner) -> Result<(), String> {
110111 return Err ( exec. failure_diagnostic ( & format ! ( "stdout is exactly {expected_stdout:?}" ) ) ) ;
111112 }
112113
114+ delete_sandbox ( runner, & sandbox_name, "delete" ) . await
115+ }
116+
117+ async fn create_sandbox (
118+ runner : & mut OpenShellRunner ,
119+ sandbox_name : & str ,
120+ step : & str ,
121+ ) -> Result < ( ) , String > {
122+ runner. track_sandbox ( sandbox_name) ;
123+ let mut args = vec ! [
124+ "sandbox" . to_string( ) ,
125+ "create" . to_string( ) ,
126+ "--name" . to_string( ) ,
127+ sandbox_name. to_string( ) ,
128+ "--detach" . to_string( ) ,
129+ ] ;
130+ if let Some ( command) = smoke_command ( ) ? {
131+ args. push ( "--" . to_string ( ) ) ;
132+ args. extend ( command) ;
133+ }
134+ let args = args. iter ( ) . map ( String :: as_str) . collect :: < Vec < _ > > ( ) ;
135+ let create = runner
136+ . step ( step)
137+ . description ( "sandbox creation succeeds" )
138+ . with_timeout ( CREATE_TIMEOUT )
139+ . run ( & args)
140+ . await
141+ . map_err ( |error| error. to_string ( ) ) ?;
142+ create. require_success ( )
143+ }
144+
145+ fn smoke_command ( ) -> Result < Option < Vec < String > > , String > {
146+ parse_smoke_command ( std:: env:: var_os ( "OPENSHELL_CONFORMANCE_SMOKE_COMMAND" ) )
147+ }
148+
149+ fn parse_smoke_command ( value : Option < OsString > ) -> Result < Option < Vec < String > > , String > {
150+ let Some ( value) = value else {
151+ return Ok ( None ) ;
152+ } ;
153+ let value = value. into_string ( ) . map_err ( |_| {
154+ "OPENSHELL_CONFORMANCE_SMOKE_COMMAND must contain valid Unicode JSON" . to_string ( )
155+ } ) ?;
156+ let command = serde_json:: from_str :: < Vec < String > > ( & value) . map_err ( |error| {
157+ format ! ( "OPENSHELL_CONFORMANCE_SMOKE_COMMAND must be a JSON string array: {error}" )
158+ } ) ?;
159+ if command. first ( ) . is_none_or ( String :: is_empty) {
160+ return Err (
161+ "OPENSHELL_CONFORMANCE_SMOKE_COMMAND must contain a non-empty executable" . to_string ( ) ,
162+ ) ;
163+ }
164+ Ok ( Some ( command) )
165+ }
166+
167+ async fn delete_sandbox (
168+ runner : & mut OpenShellRunner ,
169+ sandbox_name : & str ,
170+ step : & str ,
171+ ) -> Result < ( ) , String > {
113172 let delete = runner
114- . step ( "delete" )
173+ . step ( step )
115174 . description ( "sandbox deletion succeeds" )
116175 . with_timeout ( DELETE_TIMEOUT )
117- . run ( & [ "sandbox" , "delete" , & sandbox_name] )
176+ . run ( & [ "sandbox" , "delete" , sandbox_name] )
118177 . await
119178 . map_err ( |error| error. to_string ( ) ) ?;
120179 delete. require_success ( ) ?;
121180
122- check_empty_list ( runner, & sandbox_name) . await ?;
123- runner. forget_sandbox ( & sandbox_name) ;
181+ check_empty_list ( runner, sandbox_name) . await ?;
182+ runner. forget_sandbox ( sandbox_name) ;
183+ Ok ( ( ) )
184+ }
185+
186+ async fn check_sandbox_ready ( runner : & OpenShellRunner , sandbox_name : & str ) -> Result < ( ) , String > {
187+ let get = runner
188+ . step ( "get-ready" )
189+ . description ( format ! ( "sandbox '{sandbox_name}' can be retrieved" ) )
190+ . with_timeout ( LIST_ATTEMPT_TIMEOUT )
191+ . run ( & [ "sandbox" , "get" , sandbox_name, "--output" , "json" ] )
192+ . await
193+ . map_err ( |error| error. to_string ( ) ) ?;
194+ get. require_success ( ) ?;
195+
196+ let sandbox = get
197+ . json :: < SandboxListEntry > ( )
198+ . map_err ( |error| error. to_string ( ) ) ?;
199+ if sandbox. name != sandbox_name {
200+ return Err ( format ! (
201+ "sandbox get returned {:?}; expected sandbox '{sandbox_name}'" ,
202+ sandbox. name
203+ ) ) ;
204+ }
205+ if sandbox. phase != "Ready" {
206+ return Err ( format ! (
207+ "sandbox '{sandbox_name}' is in phase {:?}; expected Ready" ,
208+ sandbox. phase
209+ ) ) ;
210+ }
124211 Ok ( ( ) )
125212}
126213
@@ -204,3 +291,32 @@ async fn find_sandbox(
204291 . ok_or_else ( || "sandbox list page counter overflowed" . to_string ( ) ) ?;
205292 }
206293}
294+
295+ #[ cfg( test) ]
296+ mod tests {
297+ use super :: * ;
298+
299+ #[ test]
300+ fn smoke_command_is_optional ( ) {
301+ assert_eq ! ( parse_smoke_command( None ) . unwrap( ) , None ) ;
302+ }
303+
304+ #[ test]
305+ fn smoke_command_parses_a_json_string_array ( ) {
306+ assert_eq ! (
307+ parse_smoke_command( Some ( OsString :: from( r#"["cmd.exe","/c","exit","0"]"# ) ) ) . unwrap( ) ,
308+ Some ( vec![
309+ "cmd.exe" . into( ) ,
310+ "/c" . into( ) ,
311+ "exit" . into( ) ,
312+ "0" . into( )
313+ ] )
314+ ) ;
315+ }
316+
317+ #[ test]
318+ fn smoke_command_rejects_an_empty_executable ( ) {
319+ let error = parse_smoke_command ( Some ( OsString :: from ( r#"[""]"# ) ) ) . unwrap_err ( ) ;
320+ assert ! ( error. contains( "non-empty executable" ) ) ;
321+ }
322+ }
0 commit comments