flowproof 0.23.26__tar.gz → 0.23.28__tar.gz

{flowproof-0.23.26 → flowproof-0.23.28}/Cargo.lock

@@ -930,7 +930,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-adapters"
-version = "0.23.26"
+version = "0.23.28"
 dependencies = [
  "anyhow",
  "flowproof-driver",
@@ -949,7 +949,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-agent"
-version = "0.23.26"
+version = "0.23.28"
 dependencies = [
  "base64",
  "chrono",
@@ -968,7 +968,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-cli"
-version = "0.23.26"
+version = "0.23.28"
 dependencies = [
  "ab_glyph",
  "chrono",
@@ -994,7 +994,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-driver"
-version = "0.23.26"
+version = "0.23.28"
 dependencies = [
  "calamine",
  "flowproof-trace",
@@ -1010,7 +1010,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-python"
-version = "0.23.26"
+version = "0.23.28"
 dependencies = [
  "flowproof-agent",
  "flowproof-cli",
@@ -1022,7 +1022,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-replay"
-version = "0.23.26"
+version = "0.23.28"
 dependencies = [
  "chrono",
  "flowproof-agent",
@@ -1036,7 +1036,7 @@ dependencies = [
 
 [[package]]
 name = "flowproof-trace"
-version = "0.23.26"
+version = "0.23.28"
 dependencies = [
  "jsonschema",
  "regex",

{flowproof-0.23.26 → flowproof-0.23.28}/Cargo.toml

@@ -22,7 +22,7 @@ members = ["crates/flowproof-driver", "crates/flowproof-trace", "crates/flowproo
 exclude = ["spike/windows-containment"]
 
 [workspace.package]
-version = "0.23.26"
+version = "0.23.28"
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/automators-com/flowproof"

{flowproof-0.23.26 → flowproof-0.23.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowproof
-Version: 0.23.26
+Version: 0.23.28
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{flowproof-0.23.26 → flowproof-0.23.28}/crates/flowproof-adapters/src/sap_com.rs

@@ -98,6 +98,13 @@ pub trait SapEngine {
     /// VKey table has no Alt chords, so this is the only way to send it.
     fn close_window(&mut self) -> Result<(), DriverError>;
     fn screen_size(&mut self) -> Result<(u32, u32), DriverError>;
+    /// Maximize the connected session's main window and bring it to the
+    /// foreground, as a headed browser is at launch, so a person watching
+    /// the run sees the screen being driven. Scripting works on a window
+    /// that is behind others, so this is for the watcher, not the driver.
+    fn present_window(&mut self) -> Result<(), DriverError> {
+        Ok(())
+    }
     /// The session's `Info`: where the user is, for a failure report.
     /// `Ok(None)` when the engine cannot say.
     fn session_info(&mut self) -> Result<Option<SapSessionInfo>, DriverError> {
@@ -307,7 +314,15 @@ impl<E: SapEngine> AppDriver for SapAppDriver<E> {
         // `command` carries the SAP Logon connection description (may be
         // empty: attach to whatever logged-in session exists).
         self.engine
-            .connect(command, self.credentials.as_ref(), timeout)
+            .connect(command, self.credentials.as_ref(), timeout)?;
+        // Every launch presents, including a multi-surface return visit, so
+        // coming back from the browser puts SAP in front again. A window
+        // that will not come forward is no reason to fail a run that can
+        // still drive it.
+        if let Err(error) = self.engine.present_window() {
+            eprintln!("sap: could not bring the SAP GUI window to the front: {error}");
+        }
+        Ok(())
     }
 
     fn stage_credentials(&mut self, credentials: LoginCredentials) -> Result<(), DriverError> {
@@ -577,6 +592,10 @@ pub mod fake {
         pub vkeys: Vec<u16>,
         pub set_texts: Vec<(String, String)>,
         pub session_info: Option<SapSessionInfo>,
+        /// How many times the window was maximized and brought to the front.
+        pub presented: u32,
+        /// Make `present_window` fail, as a refused foreground would.
+        pub refuse_present: bool,
     }
 
     impl FakeEngine {
@@ -693,6 +712,18 @@ pub mod fake {
             Ok((1920, 1080))
         }
 
+        /// Only a connected session has a window to present.
+        fn present_window(&mut self) -> Result<(), DriverError> {
+            if self.connected.is_none() {
+                return Err(DriverError::Uia("fake sap: not connected".into()));
+            }
+            if self.refuse_present {
+                return Err(DriverError::Uia("fake sap: foreground refused".into()));
+            }
+            self.presented += 1;
+            Ok(())
+        }
+
         fn session_info(&mut self) -> Result<Option<SapSessionInfo>, DriverError> {
             Ok(self.session_info.clone())
         }
@@ -748,6 +779,7 @@ pub mod com {
     use std::time::{Duration, Instant};
 
     use windows::core::{Interface, BSTR, GUID, PCWSTR};
+    use windows::Win32::Foundation::HWND;
     use windows::Win32::System::Com::{
         CoInitializeEx, CoTaskMemFree, CreateBindCtx, GetRunningObjectTable, IDispatch,
         COINIT_APARTMENTTHREADED, DISPATCH_FLAGS, DISPATCH_METHOD, DISPATCH_PROPERTYGET,
@@ -755,7 +787,9 @@ pub mod com {
     };
     use windows::Win32::System::Ole::DISPID_PROPERTYPUT;
     use windows::Win32::System::Variant::VARIANT;
-    use windows::Win32::UI::WindowsAndMessaging::{GetSystemMetrics, SM_CXSCREEN, SM_CYSCREEN};
+    use windows::Win32::UI::WindowsAndMessaging::{
+        GetSystemMetrics, SetForegroundWindow, SM_CXSCREEN, SM_CYSCREEN,
+    };
 
     use super::{SapElement, SapEngine, SapSessionInfo};
     use flowproof_driver::{DriverError, LoginCredentials};
@@ -1462,6 +1496,25 @@ pub mod com {
             Ok((w.unsigned_abs().max(1), h.unsigned_abs().max(1)))
         }
 
+        /// The main window, not the active one: a popup open at launch is
+        /// owned by `wnd[0]` and comes forward with it, and maximizing the
+        /// popup itself would fill the screen with a dialog.
+        fn present_window(&mut self) -> Result<(), DriverError> {
+            let window = self
+                .find_disp("wnd[0]")?
+                .ok_or_else(|| DriverError::Uia("sap-com: no main window".into()))?;
+            // Maximize also restores a minimized window.
+            window.call("Maximize", vec![])?;
+            // `Handle` is the window's HWND as a Long; Windows sign-extends
+            // 32-bit handles, so the cast is the documented conversion.
+            if let Some(handle) = window.get_i32("Handle").filter(|handle| *handle != 0) {
+                // Foregrounding can be refused (focus-steal prevention); the
+                // window is still maximized and drivable, so not an error.
+                let _ = unsafe { SetForegroundWindow(HWND(handle as isize as *mut _)) };
+            }
+            Ok(())
+        }
+
         fn session_info(&mut self) -> Result<Option<SapSessionInfo>, DriverError> {
             let info = self.session()?.get_disp("Info")?;
             Ok(Some(SapSessionInfo {
@@ -1813,6 +1866,33 @@ mod tests {
         );
     }
 
+    /// A person watching a run sees SAP in front, as they see the browser,
+    /// and again on every return visit from another surface.
+    #[test]
+    fn every_launch_brings_the_connected_window_to_the_front() {
+        let mut driver = driver();
+        driver
+            .launch("TS3", "SAP", Duration::from_secs(1))
+            .expect("connects");
+        assert_eq!(driver.engine.presented, 1);
+        driver
+            .launch("TS3", "SAP", Duration::from_secs(1))
+            .expect("re-attaches");
+        assert_eq!(driver.engine.presented, 2);
+    }
+
+    #[test]
+    fn a_window_that_will_not_come_forward_does_not_fail_the_launch() {
+        let mut driver = SapAppDriver::with_engine(FakeEngine {
+            refuse_present: true,
+            ..FakeEngine::with_elements(order_screen())
+        });
+        driver
+            .launch("TS3", "SAP", Duration::from_secs(1))
+            .expect("scripting still drives a window behind others");
+        assert_eq!(driver.engine.connected.as_deref(), Some("TS3"));
+    }
+
     /// A password that reaches a log line or an error is a password that
     /// reaches CI output.
     #[test]

{flowproof-0.23.26 → flowproof-0.23.28}/crates/flowproof-agent/src/recorder.rs

@@ -1562,8 +1562,13 @@ fn driver_key_mod(m: &flowproof_trace::format::KeyModifier) -> flowproof_driver:
 /// the inverse of `selectors_for` for the shapes the recorder itself
 /// emits. `None` = not reconstructable (reuse falls back to fresh
 /// authoring, never to a guess).
+///
+/// An `a11y` selector is not the target the step was recorded with: it is a
+/// hint [`enrich_a11y_hint`] prepends afterwards so replay tries it first,
+/// and it carries a role and name, not a target. Read past it, or every web
+/// step with an accessible name is authored again on reuse.
 fn target_from_selector(selectors: &[Selector]) -> Option<Target> {
-    let primary = selectors.first()?;
+    let primary = selectors.iter().find(|s| s.tier != SelectorTier::A11y)?;
     let get = |key: &str| primary.payload.get(key).and_then(|v| v.as_str());
     let base = if let Some(css) = get("css") {
         Target::css(css)
@@ -3108,6 +3113,12 @@ struct LiveSteps {
     finished: usize,
     current: Option<(String, std::time::Instant)>,
     lines: Vec<String>,
+    /// The trace steps of every flow step that passed, kept as each one
+    /// finishes so a failure can hand them back (see
+    /// [`LocatedRecordError::completed`]).
+    completed: Vec<Step>,
+    /// How far into the recorder's `steps` [`Self::completed`] has read.
+    kept_through: usize,
 }
 
 impl LiveSteps {
@@ -3122,6 +3133,20 @@ impl LiveSteps {
         self.current = Some((intent.to_string(), std::time::Instant::now()));
     }
 
+    /// Keep the trace steps the flow step that just passed added, less the
+    /// writes the page refused - the same pruning the trace gets - so what a
+    /// failure hands back is exactly what the trace would have held.
+    fn keep_passed(&mut self, steps: &[Step], superseded: &std::collections::BTreeSet<usize>) {
+        for (index, step) in steps.iter().enumerate().skip(self.kept_through) {
+            if !superseded.contains(&index) {
+                let mut step = step.clone();
+                step.id = format!("s{:04}", self.completed.len() + 1);
+                self.completed.push(step);
+            }
+        }
+        self.kept_through = steps.len();
+    }
+
     /// Closes the step in progress, if any: an error raised between steps
     /// (a `when:` condition, a surface switch, writing the trace) names none.
     fn finish(&mut self, mark: &str) {
@@ -3188,6 +3213,11 @@ pub struct LocatedRecordError {
     pub error: RecordError,
     /// Boxed so a `Result` carrying this stays small (clippy::result_large_err).
     pub at: Box<FailurePoint>,
+    /// The trace steps of every flow step that passed before the failure,
+    /// pruned as the trace would be. Nothing of the step that failed is in
+    /// it, even the actions it got through. Held in memory only: a failed
+    /// recording writes no trace, and this is not one.
+    pub completed: Vec<Step>,
 }
 
 impl From<RecordError> for LocatedRecordError {
@@ -3195,6 +3225,7 @@ impl From<RecordError> for LocatedRecordError {
         Self {
             error,
             at: Box::default(),
+            completed: Vec::new(),
         }
     }
 }
@@ -3257,6 +3288,7 @@ fn record_with_reuse_located<D: AppDriver, C: ModelClient>(
                 step,
                 screen: driver.failure_screen(),
             }),
+            completed: std::mem::take(&mut live.completed),
         }
     })
 }
@@ -4915,6 +4947,7 @@ fn record_steps<D: AppDriver, C: ModelClient>(
         if let Some(last) = prior_history.last_mut() {
             *last = step_history(&step_intent, &executed_summaries, is_check);
         }
+        live.keep_passed(&steps, &superseded_steps);
         live.finish("PASS");
     }
 
@@ -6041,6 +6074,82 @@ steps:
         std::fs::remove_file(&out).ok();
     }
 
+    /// What a failed recording hands back is what a repair retry replays:
+    /// every step that passed, none of the one that failed, so the retry
+    /// asks the model only about the step it patched.
+    #[test]
+    fn a_failed_recording_hands_back_the_steps_that_passed() {
+        let spec = FlowSpec::parse(
+            "name: Signup\napp: web\nurl: https://example.test\nsteps:\n  \
+             - Fill in the email and continue\n  - Save the profile\n  - Publish it\n",
+        )
+        .expect("spec parses");
+        let scene = r##"[{"target":"css:#email","tag":"input","label":"Email"},
+             {"target":"css:#next","tag":"button","text":"Next"},
+             {"target":"css:#save","tag":"button","text":"Save"},
+             {"target":"css:#publish","tag":"button","text":"Publish"}]"##;
+        let dir = std::env::temp_dir().join("flowproof-failed-hands-back-passed");
+        std::fs::create_dir_all(&dir).expect("temp dir");
+        let out = dir.join("signup.trace.jsonl");
+        let _ = std::fs::remove_file(&out);
+        let options = flowproof_driver::RecordingOptions::default;
+
+        // The model answers the first two steps and has nothing for the third.
+        let mut driver = MockAppDriver::new(&["#email", "#next", "#save", "#publish"]);
+        driver.scene = Some(scene.into());
+        let mut client = ScriptedClient::new(&[
+            r##"[{"action":"type_text","target":"css:#email","text":"me@work.example"},
+                 {"action":"click","target":"css:#next"}]"##,
+            r##"[{"action":"click","target":"css:#save"}]"##,
+        ]);
+        let failed = record_with_reuse_located(
+            &spec,
+            &mut driver,
+            &out,
+            Author::Auto,
+            Some(&mut client),
+            None,
+            options(),
+        )
+        .expect_err("the third step has no answer");
+        let intents: Vec<&str> = failed.completed.iter().map(|s| s.intent.as_str()).collect();
+        assert_eq!(
+            intents,
+            [
+                "Fill in the email and continue",
+                "Fill in the email and continue",
+                "Save the profile"
+            ]
+        );
+        let ids: Vec<&str> = failed.completed.iter().map(|s| s.id.as_str()).collect();
+        assert_eq!(ids, ["s0001", "s0002", "s0003"]);
+        assert!(!out.exists(), "a failed recording writes no trace");
+
+        // Replaying them, the model is asked about the third step only.
+        let mut driver = MockAppDriver::new(&["#email", "#next", "#save", "#publish"]);
+        driver.scene = Some(scene.into());
+        let mut client =
+            ScriptedClient::new(&[r##"[{"action":"click","target":"css:#publish"}]"##]);
+        let summary = record_with_reuse_located(
+            &spec,
+            &mut driver,
+            &out,
+            Author::Auto,
+            Some(&mut client),
+            Some(&failed.completed),
+            options(),
+        )
+        .expect("the retry records");
+        assert_eq!(
+            client.prompts.len(),
+            1,
+            "only the step that failed is authored"
+        );
+        assert_eq!(summary.reused_steps, 3);
+        assert_eq!(summary.steps, 4);
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
     /// The rejected-form guard is scoped to model authoring, and stays that
     /// way.
     ///
@@ -7049,6 +7158,37 @@ steps:
         std::fs::remove_dir_all(&dir).ok();
     }
 
+    #[test]
+    fn a_step_with_an_a11y_hint_still_decodes_for_reuse() {
+        let click = ResolvedAction::Press {
+            target: Target::css("#greet"),
+            label: "Press the greet button".into(),
+            dialog: None,
+        };
+        let mut step = step_for(1, "Press the greet button", "web", &click);
+        enrich_a11y_hint(
+            &mut step,
+            &flowproof_driver::A11yHints {
+                role: "button".into(),
+                name: "Greet".into(),
+                ancestor_role: Some("RootWebArea".into()),
+                ancestor_name: Some("Greeter".into()),
+            },
+        );
+        assert_eq!(step.selectors[0].tier, SelectorTier::A11y, "the hint leads");
+        assert_eq!(decode_step(&step), Some(click));
+
+        let only_a_hint = Step {
+            selectors: step.selectors[..1].to_vec(),
+            ..step
+        };
+        assert_eq!(
+            decode_step(&only_a_hint),
+            None,
+            "a role and name alone are not a target to reuse"
+        );
+    }
+
     #[test]
     fn upload_and_right_click_decode_back_for_reuse() {
         // decode_step must be a strict inverse of step_for so `record