tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

event_win_unittest.cc (3763B)

      1 // Copyright 2022 The Chromium Authors.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <memory>
      6 
      7 #include "agent/src/event_win.h"
      8 #include "common/utils_win.h"
      9 #include "gtest/gtest.h"
     10 
     11 namespace content_analysis {
     12 namespace sdk {
     13 namespace testing {
     14 
     15 std::unique_ptr<ContentAnalysisEventWin> CreateEvent(
     16    HANDLE handle,
     17    const BrowserInfo& browser_info,
     18    ContentAnalysisRequest request) {
     19  return std::make_unique<ContentAnalysisEventWin>(
     20      handle, browser_info, std::move(request));
     21 }
     22 
     23 TEST(EventTest, Create_BrowserInfo) {
     24  const BrowserInfo bi{12345, "/path/to/binary"};
     25  ContentAnalysisRequest request;
     26  *request.add_tags() = "foo";
     27  request.set_request_token("req-token");
     28 
     29  auto event = CreateEvent(INVALID_HANDLE_VALUE, bi, request);
     30  ASSERT_TRUE(event);
     31 
     32  ASSERT_EQ(bi.pid, event->GetBrowserInfo().pid);
     33  ASSERT_EQ(bi.binary_path, event->GetBrowserInfo().binary_path);
     34 }
     35 
     36 TEST(EventTest, Create_Request) {
     37  const BrowserInfo bi{ 12345, "/path/to/binary" };
     38  ContentAnalysisRequest request;
     39  *request.add_tags() = "foo";
     40  request.set_request_token("req-token");
     41 
     42  auto event = CreateEvent(INVALID_HANDLE_VALUE, bi, request);
     43  ASSERT_TRUE(event);
     44 
     45  ASSERT_EQ(1u, event->GetRequest().tags_size());
     46  ASSERT_EQ(request.tags(0), event->GetRequest().tags(0));
     47  ASSERT_TRUE(event->GetRequest().has_request_token());
     48  ASSERT_EQ(request.request_token(), event->GetRequest().request_token());
     49 }
     50 
     51 TEST(EventTest, Create_Init) {
     52  const BrowserInfo bi{ 12345, "/path/to/binary" };
     53  ContentAnalysisRequest request;
     54  *request.add_tags() = "foo";
     55  request.set_request_token("req-token");
     56 
     57  auto event = CreateEvent(INVALID_HANDLE_VALUE, bi, request);
     58  ASSERT_TRUE(event);
     59 
     60  ASSERT_EQ(ResultCode::OK, event->Init());
     61 
     62  // Initializing an event should initialize the contained response for a
     63  // success verdict that matches the request.
     64  ASSERT_EQ(request.request_token(), event->GetResponse().request_token());
     65  ASSERT_EQ(1u, event->GetResponse().results_size());
     66  ASSERT_EQ(ContentAnalysisResponse::Result::SUCCESS,
     67            event->GetResponse().results(0).status());
     68  ASSERT_TRUE(event->GetResponse().results(0).has_tag());
     69  ASSERT_EQ(request.tags(0), event->GetResponse().results(0).tag());
     70  ASSERT_EQ(0u, event->GetResponse().results(0).triggered_rules_size());
     71 }
     72 
     73 // Initializing an event whose request has no request token is an error.
     74 TEST(EventTest, Create_Init_RequestNoRequestToken) {
     75  const BrowserInfo bi{ 12345, "/path/to/binary" };
     76  ContentAnalysisRequest request;
     77  *request.add_tags() = "foo";
     78 
     79  auto event = CreateEvent(INVALID_HANDLE_VALUE, bi, request);
     80  ASSERT_TRUE(event);
     81 
     82  ASSERT_EQ(ResultCode::ERR_MISSING_REQUEST_TOKEN, event->Init());
     83 }
     84 
     85 TEST(EventTest, Write_BadPipe) {
     86  HANDLE pipe;
     87  DWORD err = internal::CreatePipe(
     88      internal::GetPipeNameForAgent("testpipe", false), false, true, &pipe);
     89  ASSERT_EQ(ERROR_SUCCESS, err);
     90  ASSERT_NE(INVALID_HANDLE_VALUE, pipe);
     91 
     92  // Create an event with the dummy pipe and initilalize it.
     93  const BrowserInfo bi{ 12345, "/path/to/binary" };
     94  ContentAnalysisRequest request;
     95  request.set_request_token("req-token");
     96  *request.add_tags() = "dlp";
     97  request.set_text_content("test");
     98  auto event = std::make_unique<ContentAnalysisEventWin>(
     99      pipe, bi, std::move(request));
    100  ASSERT_TRUE(event);
    101  ResultCode rc = event->Init();
    102  ASSERT_EQ(ResultCode::OK, rc);
    103 
    104  // Close the handle before trying to send the response.
    105  // This simulates an error with the pipe.
    106  CloseHandle(pipe);
    107  ASSERT_EQ(ERROR_SUCCESS, GetLastError());
    108 
    109  // The following call should not hang.
    110  event->Send();
    111 }
    112 
    113 }  // namespace testing
    114 }  // namespace sdk
    115 }  // namespace content_analysis