tests/tests_before_queue.rs

   1 use std::fs::File;
   2 use std::io::BufReader;
   3 use std::process::Command;
   4 mod utils;
   5
   6 #[test]
   7 fn before_queue_start_end_time_string() {
   8     let output = Command::new(utils::log_tracker_path())
   9         .arg("-vv")
  10         .arg("-s")
  11         .arg("2020-12-18 15:00:00")
  12         .arg("-e")
  13         .arg("2020-12-18 15:40:00")
  14         .arg("-i")
  15         .arg("tests/test_input_mixed")
  16         .output()
  17         .expect("failed to execute pmg-log-tracker");
  18
  19     let expected_file = File::open("tests/test_output_before_queue")
  20         .expect("failed to open test_output");
  21
  22     let expected_output = BufReader::new(&expected_file);
  23     let output_reader = BufReader::new(&output.stdout[..]);
  24     utils::compare_output(output_reader, expected_output);
  25 }
  26
  27 #[test]
  28 fn before_queue_start_end_timestamp() {
  29     let output = Command::new(utils::log_tracker_path())
  30         .arg("-vv")
  31         .arg("-s")
  32         .arg("1608300000")
  33         .arg("-e")
  34         .arg("1608302400")
  35         .arg("-i")
  36         .arg("tests/test_input_mixed")
  37         .output()
  38         .expect("failed to execute pmg-log-tracker");
  39
  40     let expected_file = File::open("tests/test_output_before_queue")
  41         .expect("failed to open test_output");
  42
  43     let expected_output = BufReader::new(&expected_file);
  44     let output_reader = BufReader::new(&output.stdout[..]);
  45     utils::compare_output(output_reader, expected_output);
  46 }
  47
  48 #[test]
  49 fn before_queue_qid() {
  50     let output = Command::new(utils::log_tracker_path())
  51         .arg("-vv")
  52         .arg("-s")
  53         .arg("1608300000")
  54         .arg("-e")
  55         .arg("1608302400")
  56         .arg("-i")
  57         .arg("tests/test_input_mixed")
  58         .arg("-q")
  59         .arg("1C6B541C5D")
  60         .output()
  61         .expect("failed to execute pmg-log-tracker");
  62
  63     let expected_file = File::open("tests/test_output_before_queue_qid")
  64         .expect("failed to open test_output");
  65
  66     let expected_output = BufReader::new(&expected_file);
  67     let output_reader = BufReader::new(&output.stdout[..]);
  68     utils::compare_output(output_reader, expected_output);
  69 }
  70
  71 #[test]
  72 fn before_queue_host() {
  73     let output = Command::new(utils::log_tracker_path())
  74         .arg("-vv")
  75         .arg("-s")
  76         .arg("1608300000")
  77         .arg("-e")
  78         .arg("1608302400")
  79         .arg("-i")
  80         .arg("tests/test_input_mixed")
  81         .arg("-h")
  82         .arg("localhost")
  83         .output()
  84         .expect("failed to execute pmg-log-tracker");
  85
  86     let expected_file = File::open("tests/test_output_before_queue_host")
  87         .expect("failed to open test_output");
  88
  89     let expected_output = BufReader::new(&expected_file);
  90     let output_reader = BufReader::new(&output.stdout[..]);
  91     utils::compare_output(output_reader, expected_output);
  92 }
  93
  94 #[test]
  95 fn before_queue_search_string() {
  96     let output = Command::new(utils::log_tracker_path())
  97         .arg("-vv")
  98         .arg("-s")
  99         .arg("1608300000")
 100         .arg("-e")
 101         .arg("1608302400")
 102         .arg("-i")
 103         .arg("tests/test_input_mixed")
 104         .arg("-x")
 105         .arg("reject")
 106         .output()
 107         .expect("failed to execute pmg-log-tracker");
 108
 109     let expected_file = File::open("tests/test_output_before_queue_search_string")
 110         .expect("failed to open test_output");
 111
 112     let expected_output = BufReader::new(&expected_file);
 113     let output_reader = BufReader::new(&output.stdout[..]);
 114     utils::compare_output(output_reader, expected_output);
 115 }
 116
 117 #[test]
 118 fn before_queue_search_string_case_insensitive() {
 119     let output = Command::new(utils::log_tracker_path())
 120         .arg("-vv")
 121         .arg("-s")
 122         .arg("1608300000")
 123         .arg("-e")
 124         .arg("1608302400")
 125         .arg("-i")
 126         .arg("tests/test_input_mixed")
 127         .arg("-x")
 128         .arg("reJECT")
 129         .output()
 130         .expect("failed to execute pmg-log-tracker");
 131
 132     let expected_file = File::open("tests/test_output_before_queue_search_string")
 133         .expect("failed to open test_output");
 134
 135     let expected_output = BufReader::new(&expected_file);
 136     let output_reader = BufReader::new(&output.stdout[..]);
 137     utils::compare_output(output_reader, expected_output);
 138 }
 139
 140 #[test]
 141 fn before_queue_exclude_greylist_ndr() {
 142     let output = Command::new(utils::log_tracker_path())
 143         .arg("-vv")
 144         .arg("-s")
 145         .arg("1608300000")
 146         .arg("-e")
 147         .arg("1608302400")
 148         .arg("-i")
 149         .arg("tests/test_input_mixed")
 150         .arg("-g")
 151         .arg("-n")
 152         .output()
 153         .expect("failed to execute pmg-log-tracker");
 154
 155     let expected_file = File::open("tests/test_output_before_queue")
 156         .expect("failed to open test_output");
 157
 158     let expected_output = BufReader::new(&expected_file);
 159     let output_reader = BufReader::new(&output.stdout[..]);
 160     utils::compare_output(output_reader, expected_output);
 161 }
 162
 163 #[test]
 164 fn before_queue_to() {
 165     let output = Command::new(utils::log_tracker_path())
 166         .arg("-vv")
 167         .arg("-s")
 168         .arg("1608300000")
 169         .arg("-e")
 170         .arg("1608302400")
 171         .arg("-i")
 172         .arg("tests/test_input_mixed")
 173         .arg("-t")
 174         .arg("pmgtes2")
 175         .output()
 176         .expect("failed to execute pmg-log-tracker");
 177
 178     let expected_file = File::open("tests/test_output_before_queue_to")
 179         .expect("failed to open test_output");
 180
 181     let expected_output = BufReader::new(&expected_file);
 182     let output_reader = BufReader::new(&output.stdout[..]);
 183     utils::compare_output(output_reader, expected_output);
 184 }
 185
 186 #[test]
 187 fn before_queue_mixed_downstream() {
 188     let output = Command::new(utils::log_tracker_path())
 189         .arg("-v")
 190         .arg("-s")
 191         .arg("1608303600")
 192         .arg("-e")
 193         .arg("1608304200")
 194         .arg("-i")
 195         .arg("tests/test_input_mixed")
 196         .output()
 197         .expect("failed to execute pmg-log-tracker");
 198
 199     let expected_file = File::open("tests/test_output_before_queue_mixed_downstream")
 200         .expect("failed to open test_output");
 201
 202     let expected_output = BufReader::new(&expected_file);
 203     let output_reader = BufReader::new(&output.stdout[..]);
 204     utils::compare_output(output_reader, expected_output);
 205 }
 206
 207 #[test]
 208 fn before_queue_from_to() {
 209     let output = Command::new(utils::log_tracker_path())
 210         .arg("-vv")
 211         .arg("-s")
 212         .arg("1608300000")
 213         .arg("-e")
 214         .arg("1608302400")
 215         .arg("-i")
 216         .arg("tests/test_input_mixed")
 217         .arg("-f")
 218         .arg("mailtestsender3")
 219         .arg("-t")
 220         .arg("pmgtest")
 221         .output()
 222         .expect("failed to execute pmg-log-tracker");
 223
 224     let expected_file =
 225         File::open("tests/test_output_before_queue_from_to").expect("failed to open test_output");
 226
 227     let expected_output = BufReader::new(&expected_file);
 228     let output_reader = BufReader::new(&output.stdout[..]);
 229     utils::compare_output(output_reader, expected_output);
 230 }
 231
 232 #[test]
 233 fn before_queue_mixed_accept_block_quarantine() {
 234     let output = Command::new(utils::log_tracker_path())
 235         .arg("-vv")
 236         .arg("-s")
 237         .arg("1588254000")
 238         .arg("-e")
 239         .arg("1588255200")
 240         .arg("-i")
 241         .arg("tests/test_input_mixed_accept_block_quarantine")
 242         .arg("-n")
 243         .output()
 244         .expect("failed to execute pmg-log-tracker");
 245
 246     let expected_file = File::open("tests/test_output_before_queue_mixed_accept_block_quarantine")
 247         .expect("failed to open test_output");
 248
 249     let expected_output = BufReader::new(&expected_file);
 250     let output_reader = BufReader::new(&output.stdout[..]);
 251     utils::compare_output(output_reader, expected_output);
 252 }
 253
 254 #[test]
 255 fn before_queue_to_search_string() {
 256     let output = Command::new(utils::log_tracker_path())
 257         .arg("-vv")
 258         .arg("-s")
 259         .arg("1589810100")
 260         .arg("-e")
 261         .arg("1589812000")
 262         .arg("-i")
 263         .arg("tests/test_input_before_queue_to_search_string")
 264         .arg("-t")
 265         .arg("ferdl@example.proxmox.com")
 266         .arg("-x")
 267         .arg("ferdl@example.proxmox.com")
 268         .output()
 269         .expect("failed to execute pmg-log-tracker");
 270
 271     let expected_file = File::open("tests/test_output_before_queue_to_search_string")
 272         .expect("failed to open test_output");
 273
 274     let expected_output = BufReader::new(&expected_file);
 275     let output_reader = BufReader::new(&output.stdout[..]);
 276     utils::compare_output(output_reader, expected_output);
 277 }
 278
 279 #[test]
 280 fn before_queue_syntax_reject() {
 281     let output = Command::new(utils::log_tracker_path())
 282         .arg("-vv")
 283         .arg("-s")
 284         .arg("2020-08-27 14:00:00")
 285         .arg("-e")
 286         .arg("2020-08-27 14:05:00")
 287         .arg("-i")
 288         .arg("tests/test_input_before_queue_syntax_reject")
 289         .output()
 290         .expect("failed to execute pmg-log-tracker");
 291
 292     let expected_file = File::open("tests/test_output_before_queue_syntax_reject")
 293         .expect("failed to open test_output");
 294
 295     let expected_output = BufReader::new(&expected_file);
 296     let output_reader = BufReader::new(&output.stdout[..]);
 297     utils::compare_output(output_reader, expected_output);
 298 }