run_test_suite_lib/output/
directory_with_stdout.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::output::directory::{DirectoryReporter, SchemaVersion};
6use crate::output::mux::{MultiplexedDirectoryWriter, MultiplexedWriter};
7use crate::output::shell::ShellReporter;
8use crate::output::{
9    ArtifactType, DirectoryArtifactType, DynArtifact, DynDirectoryArtifact, EntityId, EntityInfo,
10    ReportedOutcome, Reporter, SuiteId, Timestamp,
11};
12use fuchsia_sync::Mutex;
13use std::collections::HashMap;
14use std::fs::File;
15use std::io::{BufWriter, Error};
16use std::path::PathBuf;
17
18/// A reporter implementation that saves output to the structured directory output format, and also
19/// saves human-readable reports to the directory. The reports are generated per-suite, and are
20/// generated using |ShellReporter|.
21// In the future, we may want to make the type of stdout output configurable.
22pub struct DirectoryWithStdoutReporter {
23    directory_reporter: DirectoryReporter,
24    /// Set of shell reporters, one per suite. Each |ShellReporter| is routed events for a single
25    /// suite, and produces a report as if there is a run containing a single suite.
26    shell_reporters: Mutex<HashMap<SuiteId, ShellReporter<BufWriter<File>>>>,
27}
28
29impl DirectoryWithStdoutReporter {
30    pub fn new(root: PathBuf, version: SchemaVersion) -> Result<Self, Error> {
31        Ok(Self {
32            directory_reporter: DirectoryReporter::new(root, version)?,
33            shell_reporters: Mutex::new(HashMap::new()),
34        })
35    }
36
37    fn get_locked_shell_reporter(
38        &self,
39        suite: &SuiteId,
40    ) -> impl '_ + std::ops::Deref<Target = ShellReporter<BufWriter<File>>> {
41        fuchsia_sync::MutexGuard::map(self.shell_reporters.lock(), |reporters| {
42            reporters.get_mut(suite).unwrap()
43        })
44    }
45}
46
47impl Reporter for DirectoryWithStdoutReporter {
48    fn new_entity(&self, entity: &EntityId, name: &str) -> Result<(), Error> {
49        self.directory_reporter.new_entity(entity, name)?;
50
51        match entity {
52            EntityId::Suite(suite_id) => {
53                let human_readable_artifact = self.directory_reporter.add_report(entity)?;
54                let shell_reporter = ShellReporter::new(human_readable_artifact);
55                shell_reporter.new_entity(entity, name)?;
56                self.shell_reporters.lock().insert(*suite_id, shell_reporter);
57                Ok(())
58            }
59            EntityId::Case { suite, .. } => {
60                self.shell_reporters.lock().get(suite).unwrap().new_entity(entity, name)
61            }
62            EntityId::TestRun => Ok(()),
63        }
64    }
65
66    fn set_entity_info(&self, entity: &EntityId, info: &EntityInfo) {
67        self.directory_reporter.set_entity_info(entity, info);
68
69        let suite_id = match entity {
70            EntityId::Suite(suite) => Some(suite),
71            EntityId::Case { suite, .. } => Some(suite),
72            _ => None,
73        };
74        if let Some(suite) = suite_id {
75            self.get_locked_shell_reporter(suite).set_entity_info(entity, info);
76        }
77    }
78
79    fn entity_started(&self, entity: &EntityId, timestamp: Timestamp) -> Result<(), Error> {
80        self.directory_reporter.entity_started(entity, timestamp)?;
81
82        match entity {
83            EntityId::Suite(suite) => {
84                let reporter = self.get_locked_shell_reporter(suite);
85                // Since we create one reporter per suite, we should start the run at the
86                // same time as the suite.
87                reporter.entity_started(&EntityId::TestRun, timestamp)?;
88                reporter.entity_started(entity, timestamp)
89            }
90            EntityId::Case { suite, .. } => {
91                self.get_locked_shell_reporter(suite).entity_started(entity, timestamp)
92            }
93            EntityId::TestRun => Ok(()),
94        }
95    }
96
97    fn entity_stopped(
98        &self,
99        entity: &EntityId,
100        outcome: &ReportedOutcome,
101        timestamp: Timestamp,
102    ) -> Result<(), Error> {
103        self.directory_reporter.entity_stopped(entity, outcome, timestamp)?;
104
105        match entity {
106            EntityId::Suite(suite) => {
107                let reporter = self.get_locked_shell_reporter(suite);
108                // Since we create one reporter per suite, we should stop the run at the
109                // same time as the suite.
110                reporter.entity_stopped(entity, outcome, timestamp)?;
111                reporter.entity_stopped(&EntityId::TestRun, outcome, timestamp)
112            }
113            EntityId::Case { suite, .. } => {
114                self.get_locked_shell_reporter(suite).entity_stopped(entity, outcome, timestamp)
115            }
116            EntityId::TestRun => Ok(()),
117        }
118    }
119
120    fn entity_finished(&self, entity: &EntityId) -> Result<(), Error> {
121        self.directory_reporter.entity_finished(entity)?;
122
123        match entity {
124            EntityId::Suite(suite) => {
125                let reporter = self.get_locked_shell_reporter(suite);
126                // Since we create one reporter per suite, we should finish the run at the
127                // same time as the suite.
128                reporter.entity_finished(entity)?;
129                reporter.entity_finished(&EntityId::TestRun)
130            }
131            EntityId::Case { suite, .. } => {
132                self.get_locked_shell_reporter(suite).entity_finished(entity)
133            }
134            EntityId::TestRun => Ok(()),
135        }
136    }
137
138    fn new_artifact(
139        &self,
140        entity: &EntityId,
141        artifact_type: &ArtifactType,
142    ) -> Result<Box<DynArtifact>, Error> {
143        let shell_reporter_artifact = match entity {
144            EntityId::Suite(suite) | EntityId::Case { suite, .. } => {
145                Some(self.get_locked_shell_reporter(suite).new_artifact(entity, artifact_type)?)
146            }
147            EntityId::TestRun => None,
148        };
149        let directory_reporter_artifact =
150            self.directory_reporter.new_artifact(entity, artifact_type)?;
151        match shell_reporter_artifact {
152            Some(artifact) => {
153                Ok(Box::new(MultiplexedWriter::new(artifact, directory_reporter_artifact)))
154            }
155            None => Ok(directory_reporter_artifact),
156        }
157    }
158
159    fn new_directory_artifact(
160        &self,
161        entity: &EntityId,
162        artifact_type: &DirectoryArtifactType,
163        component_moniker: Option<String>,
164    ) -> Result<Box<DynDirectoryArtifact>, Error> {
165        let component_moniker_clone = component_moniker.clone();
166        let shell_reporter_artifact = match entity {
167            EntityId::Suite(suite) | EntityId::Case { suite, .. } => {
168                Some(self.get_locked_shell_reporter(suite).new_directory_artifact(
169                    entity,
170                    artifact_type,
171                    component_moniker_clone,
172                )?)
173            }
174            EntityId::TestRun => None,
175        };
176        let directory_reporter_artifact = self.directory_reporter.new_directory_artifact(
177            entity,
178            artifact_type,
179            component_moniker,
180        )?;
181        match shell_reporter_artifact {
182            Some(artifact) => {
183                Ok(Box::new(MultiplexedDirectoryWriter::new(artifact, directory_reporter_artifact)))
184            }
185            None => Ok(directory_reporter_artifact),
186        }
187    }
188}
189
190#[cfg(test)]
191mod test {
192    use super::*;
193    use crate::output::{CaseId, RunReporter};
194    use tempfile::tempdir;
195    use test_output_directory as directory;
196    use test_output_directory::testing::{
197        assert_run_result, ExpectedSuite, ExpectedTestCase, ExpectedTestRun,
198    };
199
200    // these tests are intended to verify that events are routed correctly. The actual contents
201    // are verified more thoroughly in tests for DirectoryReporter and ShellReporter.
202    // TODO(satsukiu): consider adding a reporter that outputs something more structured to stdout
203    // so that we can write more thorough tests.
204
205    #[fuchsia::test]
206    async fn directory_with_stdout() {
207        let dir = tempdir().expect("create temp directory");
208        let run_reporter = RunReporter::new(
209            DirectoryWithStdoutReporter::new(dir.path().to_path_buf(), SchemaVersion::V1).unwrap(),
210        );
211
212        for suite_no in 0..3 {
213            let suite_reporter = run_reporter
214                .new_suite(&format!("test-suite-{}", suite_no), &SuiteId(suite_no))
215                .expect("create suite");
216            suite_reporter.started(Timestamp::Unknown).expect("start suite");
217            let case_reporter =
218                suite_reporter.new_case("test-case", &CaseId(0)).expect("create test case");
219            case_reporter.started(Timestamp::Unknown).expect("start case");
220            let mut case_stdout =
221                case_reporter.new_artifact(&ArtifactType::Stdout).expect("create stdout");
222            writeln!(case_stdout, "Stdout for test case").expect("write to stdout");
223            case_stdout.flush().expect("flush stdout");
224            case_reporter.stopped(&ReportedOutcome::Passed, Timestamp::Unknown).expect("stop case");
225            case_reporter.finished().expect("finish case");
226            suite_reporter
227                .stopped(&ReportedOutcome::Passed, Timestamp::Unknown)
228                .expect("stop suite");
229            suite_reporter.finished().expect("finish suite");
230        }
231        run_reporter.stopped(&ReportedOutcome::Passed, Timestamp::Unknown).expect("stop run");
232        run_reporter.finished().expect("finish run");
233
234        let mut expected_test = ExpectedTestRun::new(directory::Outcome::Passed);
235        for suite_no in 0..3 {
236            let expected_report = format!(
237                "Running test 'test-suite-{:?}'\n\
238            [RUNNING]\ttest-case\n\
239            [stdout - test-case]\n\
240            Stdout for test case\n\
241            [PASSED]\ttest-case\n\
242            \n\
243            1 out of 1 tests passed...\n\
244            test-suite-{:?} completed with result: PASSED\n",
245                suite_no, suite_no
246            );
247            let suite = ExpectedSuite::new(
248                format!("test-suite-{:?}", suite_no),
249                directory::Outcome::Passed,
250            )
251            .with_artifact(directory::ArtifactType::Report, "report.txt".into(), &expected_report)
252            .with_case(
253                ExpectedTestCase::new("test-case", directory::Outcome::Passed).with_artifact(
254                    directory::ArtifactType::Stdout,
255                    "stdout.txt".into(),
256                    "Stdout for test case\n",
257                ),
258            );
259            expected_test = expected_test.with_suite(suite);
260        }
261
262        assert_run_result(dir.path(), &expected_test);
263    }
264}
run_test_suite_lib/output/directory_with_stdout.rs

run_test_suite_lib/output/
directory_with_stdout.rs
