viewpoint-core 0.4.3

High-level browser automation API for Viewpoint
Documentation 
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

//! Video file I/O operations.
//!
//! This module handles saving, copying, and deleting video files.

use std::path::{Path, PathBuf};

use tracing::info;

use crate::error::PageError;

use super::video::Video;

impl Video {
    /// Save the video to a specific path.
    ///
    /// This copies the recorded video to the specified location.
    ///
    /// # Example
    ///
    /// ```no_run
    /// use viewpoint_core::page::Video;
    ///
    /// # async fn example(video: &Video) -> Result<(), viewpoint_core::CoreError> {
    /// video.save_as("./test-results/my-test.webm").await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn save_as(&self, path: impl AsRef<Path>) -> Result<(), PageError> {
        let current_path = self.path().await?;
        let target_path = path.as_ref();

        // Ensure parent directory exists
        if let Some(parent) = target_path.parent() {
            tokio::fs::create_dir_all(parent).await.map_err(|e| {
                PageError::EvaluationFailed(format!("Failed to create directory: {e}"))
            })?;
        }

        // Copy the video file
        tokio::fs::copy(&current_path, target_path)
            .await
            .map_err(|e| PageError::EvaluationFailed(format!("Failed to copy video: {e}")))?;

        // Also copy the frames directory if it exists (for jpeg-sequence format)
        let state = self.state.read().await;
        if let Some(ref video_path) = state.video_path {
            // Read the metadata to find frames dir
            if let Ok(content) = tokio::fs::read_to_string(video_path).await {
                if let Ok(metadata) = serde_json::from_str::<serde_json::Value>(&content) {
                    if let Some(frames_dir) = metadata.get("frames_dir").and_then(|v| v.as_str()) {
                        let source_frames = PathBuf::from(frames_dir);
                        if source_frames.exists() {
                            let target_frames = target_path.with_extension("frames");
                            copy_dir_recursive(&source_frames, &target_frames).await?;
                        }
                    }
                }
            }
        }

        info!("Video saved to {:?}", target_path);
        Ok(())
    }

    /// Delete the recorded video.
    ///
    /// This removes the video file and any associated frame data.
    ///
    /// # Example
    ///
    /// ```no_run
    /// use viewpoint_core::page::Video;
    ///
    /// # async fn example(video: &Video) -> Result<(), viewpoint_core::CoreError> {
    /// video.delete().await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn delete(&self) -> Result<(), PageError> {
        let state = self.state.read().await;

        if let Some(ref video_path) = state.video_path {
            // Read the metadata to find frames dir
            if let Ok(content) = tokio::fs::read_to_string(video_path).await {
                if let Ok(metadata) = serde_json::from_str::<serde_json::Value>(&content) {
                    if let Some(frames_dir) = metadata.get("frames_dir").and_then(|v| v.as_str()) {
                        let frames_path = PathBuf::from(frames_dir);
                        if frames_path.exists() {
                            let _ = tokio::fs::remove_dir_all(&frames_path).await;
                        }
                    }
                }
            }

            // Remove the video file
            tokio::fs::remove_file(video_path)
                .await
                .map_err(|e| PageError::EvaluationFailed(format!("Failed to delete video: {e}")))?;

            info!("Video deleted");
        }

        Ok(())
    }
}

/// Recursively copy a directory.
pub(super) async fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<(), PageError> {
    tokio::fs::create_dir_all(dst)
        .await
        .map_err(|e| PageError::EvaluationFailed(format!("Failed to create directory: {e}")))?;

    let mut entries = tokio::fs::read_dir(src)
        .await
        .map_err(|e| PageError::EvaluationFailed(format!("Failed to read directory: {e}")))?;

    while let Some(entry) = entries
        .next_entry()
        .await
        .map_err(|e| PageError::EvaluationFailed(format!("Failed to read directory entry: {e}")))?
    {
        let src_path = entry.path();
        let dst_path = dst.join(entry.file_name());

        if src_path.is_dir() {
            Box::pin(copy_dir_recursive(&src_path, &dst_path)).await?;
        } else {
            tokio::fs::copy(&src_path, &dst_path)
                .await
                .map_err(|e| PageError::EvaluationFailed(format!("Failed to copy file: {e}")))?;
        }
    }

    Ok(())
}