//===- unittests/Basic/SarifTest.cpp - Test writing SARIF documents -------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "clang/Basic/Sarif.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/FileSystemOptions.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/JSON.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/VirtualFileSystem.h"
#include "llvm/Support/raw_ostream.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

#include <algorithm>

using namespace clang;

namespace {

using LineCol = std::pair<unsigned int, unsigned int>;

static std::string serializeSarifDocument(llvm::json::Object &&Doc) {
  std::string Output;
  llvm::json::Value Value(std::move(Doc));
  llvm::raw_string_ostream OS{Output};
  OS << llvm::formatv("{0}", Value);
  OS.flush();
  return Output;
}

class SarifDocumentWriterTest : public ::testing::Test {
protected:
  SarifDocumentWriterTest()
      : InMemoryFileSystem(new llvm::vfs::InMemoryFileSystem),
        FileMgr(FileSystemOptions(), InMemoryFileSystem),
        DiagID(new DiagnosticIDs()), DiagOpts(new DiagnosticOptions()),
        Diags(DiagID, DiagOpts.get(), new IgnoringDiagConsumer()),
        SourceMgr(Diags, FileMgr) {}

  IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem;
  FileManager FileMgr;
  IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
  DiagnosticsEngine Diags;
  SourceManager SourceMgr;
  LangOptions LangOpts;

  FileID registerSource(llvm::StringRef Name, const char *SourceText,
                        bool IsMainFile = false) {
    std::unique_ptr<llvm::MemoryBuffer> SourceBuf =
        llvm::MemoryBuffer::getMemBuffer(SourceText);
    const FileEntry *SourceFile =
        FileMgr.getVirtualFile(Name, SourceBuf->getBufferSize(), 0);
    SourceMgr.overrideFileContents(SourceFile, std::move(SourceBuf));
    FileID FID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
    if (IsMainFile)
      SourceMgr.setMainFileID(FID);
    return FID;
  }

  CharSourceRange getFakeCharSourceRange(FileID FID, LineCol Begin,
                                         LineCol End) {
    auto BeginLoc = SourceMgr.translateLineCol(FID, Begin.first, Begin.second);
    auto EndLoc = SourceMgr.translateLineCol(FID, End.first, End.second);
    return CharSourceRange{SourceRange{BeginLoc, EndLoc}, /* ITR = */ false};
  }
};

TEST_F(SarifDocumentWriterTest, canCreateEmptyDocument) {
  // GIVEN:
  SarifDocumentWriter Writer{SourceMgr};

  // WHEN:
  const llvm::json::Object &EmptyDoc = Writer.createDocument();
  std::vector<StringRef> Keys(EmptyDoc.size());
  std::transform(EmptyDoc.begin(), EmptyDoc.end(), Keys.begin(),
                 [](auto Item) { return Item.getFirst(); });

  // THEN:
  ASSERT_THAT(Keys, testing::UnorderedElementsAre("$schema", "version"));
}

// Test that a newly inserted run will associate correct tool names
TEST_F(SarifDocumentWriterTest, canCreateDocumentWithOneRun) {
  // GIVEN:
  SarifDocumentWriter Writer{SourceMgr};
  const char *ShortName = "sariftest";
  const char *LongName = "sarif writer test";

  // WHEN:
  Writer.createRun(ShortName, LongName);
  Writer.endRun();
  const llvm::json::Object &Doc = Writer.createDocument();
  const llvm::json::Array *Runs = Doc.getArray("runs");

  // THEN:
  // A run was created
  ASSERT_THAT(Runs, testing::NotNull());

  // It is the only run
  ASSERT_EQ(Runs->size(), 1UL);

  // The tool associated with the run was the tool
  const llvm::json::Object *Driver =
      Runs->begin()->getAsObject()->getObject("tool")->getObject("driver");
  ASSERT_THAT(Driver, testing::NotNull());

  ASSERT_TRUE(Driver->getString("name").has_value());
  ASSERT_TRUE(Driver->getString("fullName").has_value());
  ASSERT_TRUE(Driver->getString("language").has_value());

  EXPECT_EQ(*Driver->getString("name"), ShortName);
  EXPECT_EQ(*Driver->getString("fullName"), LongName);
  EXPECT_EQ(*Driver->getString("language"), "en-US");
}

TEST_F(SarifDocumentWriterTest, addingResultsWillCrashIfThereIsNoRun) {
#if defined(NDEBUG) || !GTEST_HAS_DEATH_TEST
  GTEST_SKIP() << "This death test is only available for debug builds.";
#endif
  // GIVEN:
  SarifDocumentWriter Writer{SourceMgr};

  // WHEN:
  //  A SarifDocumentWriter::createRun(...) was not called prior to
  //  SarifDocumentWriter::appendResult(...)
  // But a rule exists
  auto RuleIdx = Writer.createRule(SarifRule::create());
  const SarifResult &EmptyResult = SarifResult::create(RuleIdx);

  // THEN:
  auto Matcher = ::testing::AnyOf(
      ::testing::HasSubstr("create a run first"),
      ::testing::HasSubstr("no runs associated with the document"));
  ASSERT_DEATH(Writer.appendResult(EmptyResult), Matcher);
}

TEST_F(SarifDocumentWriterTest, settingInvalidRankWillCrash) {
#if defined(NDEBUG) || !GTEST_HAS_DEATH_TEST
  GTEST_SKIP() << "This death test is only available for debug builds.";
#endif
  // GIVEN:
  SarifDocumentWriter Writer{SourceMgr};

  // WHEN:
  // A SarifReportingConfiguration is created with an invalid "rank"
  // * Ranks below 0.0 are invalid
  // * Ranks above 100.0 are invalid

  // THEN: The builder will crash in either case
  EXPECT_DEATH(SarifReportingConfiguration::create().setRank(-1.0),
               ::testing::HasSubstr("Rule rank cannot be smaller than 0.0"));
  EXPECT_DEATH(SarifReportingConfiguration::create().setRank(101.0),
               ::testing::HasSubstr("Rule rank cannot be larger than 100.0"));
}

TEST_F(SarifDocumentWriterTest, creatingResultWithDisabledRuleWillCrash) {
#if defined(NDEBUG) || !GTEST_HAS_DEATH_TEST
  GTEST_SKIP() << "This death test is only available for debug builds.";
#endif

  // GIVEN:
  SarifDocumentWriter Writer{SourceMgr};

  // WHEN:
  // A disabled Rule is created, and a result is create referencing this rule
  const auto &Config = SarifReportingConfiguration::create().disable();
  auto RuleIdx =
      Writer.createRule(SarifRule::create().setDefaultConfiguration(Config));
  const SarifResult &Result = SarifResult::create(RuleIdx);

  // THEN:
  // SarifResult::create(...) will produce a crash
  ASSERT_DEATH(
      Writer.appendResult(Result),
      ::testing::HasSubstr("Cannot add a result referencing a disabled Rule"));
}

// Test adding rule and result shows up in the final document
TEST_F(SarifDocumentWriterTest, addingResultWithValidRuleAndRunIsOk) {
  // GIVEN:
  SarifDocumentWriter Writer{SourceMgr};
  const SarifRule &Rule =
      SarifRule::create()
          .setRuleId("clang.unittest")
          .setDescription("Example rule created during unit tests")
          .setName("clang unit test");

  // WHEN:
  Writer.createRun("sarif test", "sarif test runner");
  unsigned RuleIdx = Writer.createRule(Rule);
  const SarifResult &Result = SarifResult::create(RuleIdx);

  Writer.appendResult(Result);
  const llvm::json::Object &Doc = Writer.createDocument();

  // THEN:
  // A document with a valid schema and version exists
  ASSERT_THAT(Doc.get("$schema"), ::testing::NotNull());
  ASSERT_THAT(Doc.get("version"), ::testing::NotNull());
  const llvm::json::Array *Runs = Doc.getArray("runs");

  // A run exists on this document
  ASSERT_THAT(Runs, ::testing::NotNull());
  ASSERT_EQ(Runs->size(), 1UL);
  const llvm::json::Object *TheRun = Runs->back().getAsObject();

  // The run has slots for tools, results, rules and artifacts
  ASSERT_THAT(TheRun->get("tool"), ::testing::NotNull());
  ASSERT_THAT(TheRun->get("results"), ::testing::NotNull());
  ASSERT_THAT(TheRun->get("artifacts"), ::testing::NotNull());
  const llvm::json::Object *Driver =
      TheRun->getObject("tool")->getObject("driver");
  const llvm::json::Array *Results = TheRun->getArray("results");
  const llvm::json::Array *Artifacts = TheRun->getArray("artifacts");

  // The tool is as expected
  ASSERT_TRUE(Driver->getString("name").has_value());
  ASSERT_TRUE(Driver->getString("fullName").has_value());

  EXPECT_EQ(*Driver->getString("name"), "sarif test");
  EXPECT_EQ(*Driver->getString("fullName"), "sarif test runner");

  // The results are as expected
  EXPECT_EQ(Results->size(), 1UL);

  // The artifacts are as expected
  EXPECT_TRUE(Artifacts->empty());
}

TEST_F(SarifDocumentWriterTest, checkSerializingResultsWithDefaultRuleConfig) {
  // GIVEN:
  const std::string ExpectedOutput =
      R"({"$schema":"https://docs.oasis-open.org/sarif/sarif/v2.1.0/cos02/schemas/sarif-schema-2.1.0.json","runs":[{"artifacts":[],"columnKind":"unicodeCodePoints","results":[{"level":"warning","message":{"text":""},"ruleId":"clang.unittest","ruleIndex":0}],"tool":{"driver":{"fullName":"sarif test runner","informationUri":"https://clang.llvm.org/docs/UsersManual.html","language":"en-US","name":"sarif test","rules":[{"defaultConfiguration":{"enabled":true,"level":"warning","rank":-1},"fullDescription":{"text":"Example rule created during unit tests"},"id":"clang.unittest","name":"clang unit test"}],"version":"1.0.0"}}}],"version":"2.1.0"})";

  SarifDocumentWriter Writer{SourceMgr};
  const SarifRule &Rule =
      SarifRule::create()
          .setRuleId("clang.unittest")
          .setDescription("Example rule created during unit tests")
          .setName("clang unit test");

  // WHEN: A run contains a result
  Writer.createRun("sarif test", "sarif test runner", "1.0.0");
  unsigned RuleIdx = Writer.createRule(Rule);
  const SarifResult &Result = SarifResult::create(RuleIdx);
  Writer.appendResult(Result);
  std::string Output = serializeSarifDocument(Writer.createDocument());

  // THEN:
  ASSERT_THAT(Output, ::testing::StrEq(ExpectedOutput));
}

TEST_F(SarifDocumentWriterTest, checkSerializingResultsWithCustomRuleConfig) {
  // GIVEN:
  const std::string ExpectedOutput =
      R"({"$schema":"https://docs.oasis-open.org/sarif/sarif/v2.1.0/cos02/schemas/sarif-schema-2.1.0.json","runs":[{"artifacts":[],"columnKind":"unicodeCodePoints","results":[{"level":"error","message":{"text":""},"ruleId":"clang.unittest","ruleIndex":0}],"tool":{"driver":{"fullName":"sarif test runner","informationUri":"https://clang.llvm.org/docs/UsersManual.html","language":"en-US","name":"sarif test","rules":[{"defaultConfiguration":{"enabled":true,"level":"error","rank":35.5},"fullDescription":{"text":"Example rule created during unit tests"},"id":"clang.unittest","name":"clang unit test"}],"version":"1.0.0"}}}],"version":"2.1.0"})";

  SarifDocumentWriter Writer{SourceMgr};
  const SarifRule &Rule =
      SarifRule::create()
          .setRuleId("clang.unittest")
          .setDescription("Example rule created during unit tests")
          .setName("clang unit test")
          .setDefaultConfiguration(SarifReportingConfiguration::create()
                                       .setLevel(SarifResultLevel::Error)
                                       .setRank(35.5));

  // WHEN: A run contains a result
  Writer.createRun("sarif test", "sarif test runner", "1.0.0");
  unsigned RuleIdx = Writer.createRule(Rule);
  const SarifResult &Result = SarifResult::create(RuleIdx);
  Writer.appendResult(Result);
  std::string Output = serializeSarifDocument(Writer.createDocument());

  // THEN:
  ASSERT_THAT(Output, ::testing::StrEq(ExpectedOutput));
}

// Check that serializing artifacts from results produces valid SARIF
TEST_F(SarifDocumentWriterTest, checkSerializingArtifacts) {
  // GIVEN:
  const std::string ExpectedOutput =
      R"({"$schema":"https://docs.oasis-open.org/sarif/sarif/v2.1.0/cos02/schemas/sarif-schema-2.1.0.json","runs":[{"artifacts":[{"length":40,"location":{"index":0,"uri":"file:///main.cpp"},"mimeType":"text/plain","roles":["resultFile"]}],"columnKind":"unicodeCodePoints","results":[{"level":"error","locations":[{"physicalLocation":{"artifactLocation":{"index":0,"uri":"file:///main.cpp"},"region":{"endColumn":14,"startColumn":14,"startLine":3}}}],"message":{"text":"expected ';' after top level declarator"},"ruleId":"clang.unittest","ruleIndex":0}],"tool":{"driver":{"fullName":"sarif test runner","informationUri":"https://clang.llvm.org/docs/UsersManual.html","language":"en-US","name":"sarif test","rules":[{"defaultConfiguration":{"enabled":true,"level":"warning","rank":-1},"fullDescription":{"text":"Example rule created during unit tests"},"id":"clang.unittest","name":"clang unit test"}],"version":"1.0.0"}}}],"version":"2.1.0"})";

  SarifDocumentWriter Writer{SourceMgr};
  const SarifRule &Rule =
      SarifRule::create()
          .setRuleId("clang.unittest")
          .setDescription("Example rule created during unit tests")
          .setName("clang unit test");

  // WHEN: A result is added with valid source locations for its diagnostics
  Writer.createRun("sarif test", "sarif test runner", "1.0.0");
  unsigned RuleIdx = Writer.createRule(Rule);

  llvm::SmallVector<CharSourceRange, 1> DiagLocs;
  const char *SourceText = "int foo = 0;\n"
                           "int bar = 1;\n"
                           "float x = 0.0\n";

  FileID MainFileID =
      registerSource("/main.cpp", SourceText, /* IsMainFile = */ true);
  CharSourceRange SourceCSR =
      getFakeCharSourceRange(MainFileID, {3, 14}, {3, 14});

  DiagLocs.push_back(SourceCSR);

  const SarifResult &Result =
      SarifResult::create(RuleIdx)
          .setLocations(DiagLocs)
          .setDiagnosticMessage("expected ';' after top level declarator")
          .setDiagnosticLevel(SarifResultLevel::Error);
  Writer.appendResult(Result);
  std::string Output = serializeSarifDocument(Writer.createDocument());

  // THEN: Assert that the serialized SARIF is as expected
  ASSERT_THAT(Output, ::testing::StrEq(ExpectedOutput));
}

TEST_F(SarifDocumentWriterTest, checkSerializingCodeflows) {
  // GIVEN:
  const std::string ExpectedOutput =
      R"({"$schema":"https://docs.oasis-open.org/sarif/sarif/v2.1.0/cos02/schemas/sarif-schema-2.1.0.json","runs":[{"artifacts":[{"length":41,"location":{"index":0,"uri":"file:///main.cpp"},"mimeType":"text/plain","roles":["resultFile"]},{"length":27,"location":{"index":1,"uri":"file:///test-header-1.h"},"mimeType":"text/plain","roles":["resultFile"]},{"length":30,"location":{"index":2,"uri":"file:///test-header-2.h"},"mimeType":"text/plain","roles":["resultFile"]},{"length":28,"location":{"index":3,"uri":"file:///test-header-3.h"},"mimeType":"text/plain","roles":["resultFile"]}],"columnKind":"unicodeCodePoints","results":[{"codeFlows":[{"threadFlows":[{"locations":[{"importance":"essential","location":{"message":{"text":"Message #1"},"physicalLocation":{"artifactLocation":{"index":1,"uri":"file:///test-header-1.h"},"region":{"endColumn":8,"endLine":2,"startColumn":1,"startLine":1}}}},{"importance":"important","location":{"message":{"text":"Message #2"},"physicalLocation":{"artifactLocation":{"index":2,"uri":"file:///test-header-2.h"},"region":{"endColumn":8,"endLine":2,"startColumn":1,"startLine":1}}}},{"importance":"unimportant","location":{"message":{"text":"Message #3"},"physicalLocation":{"artifactLocation":{"index":3,"uri":"file:///test-header-3.h"},"region":{"endColumn":8,"endLine":2,"startColumn":1,"startLine":1}}}}]}]}],"level":"warning","locations":[{"physicalLocation":{"artifactLocation":{"index":0,"uri":"file:///main.cpp"},"region":{"endColumn":8,"endLine":2,"startColumn":5,"startLine":2}}}],"message":{"text":"Redefinition of 'foo'"},"ruleId":"clang.unittest","ruleIndex":0}],"tool":{"driver":{"fullName":"sarif test runner","informationUri":"https://clang.llvm.org/docs/UsersManual.html","language":"en-US","name":"sarif test","rules":[{"defaultConfiguration":{"enabled":true,"level":"warning","rank":-1},"fullDescription":{"text":"Example rule created during unit tests"},"id":"clang.unittest","name":"clang unit test"}],"version":"1.0.0"}}}],"version":"2.1.0"})";

  const char *SourceText = "int foo = 0;\n"
                           "int foo = 1;\n"
                           "float x = 0.0;\n";
  FileID MainFileID =
      registerSource("/main.cpp", SourceText, /* IsMainFile = */ true);
  CharSourceRange DiagLoc{getFakeCharSourceRange(MainFileID, {2, 5}, {2, 8})};

  SarifDocumentWriter Writer{SourceMgr};
  const SarifRule &Rule =
      SarifRule::create()
          .setRuleId("clang.unittest")
          .setDescription("Example rule created during unit tests")
          .setName("clang unit test");

  constexpr unsigned int NumCases = 3;
  llvm::SmallVector<ThreadFlow, NumCases> Threadflows;
  const char *HeaderTexts[NumCases]{("#pragma once\n"
                                     "#include <foo>"),
                                    ("#ifndef FOO\n"
                                     "#define FOO\n"
                                     "#endif"),
                                    ("#ifdef FOO\n"
                                     "#undef FOO\n"
                                     "#endif")};
  const char *HeaderNames[NumCases]{"/test-header-1.h", "/test-header-2.h",
                                    "/test-header-3.h"};
  ThreadFlowImportance Importances[NumCases]{ThreadFlowImportance::Essential,
                                             ThreadFlowImportance::Important,
                                             ThreadFlowImportance::Unimportant};
  for (size_t Idx = 0; Idx != NumCases; ++Idx) {
    FileID FID = registerSource(HeaderNames[Idx], HeaderTexts[Idx]);
    CharSourceRange &&CSR = getFakeCharSourceRange(FID, {1, 1}, {2, 8});
    std::string Message = llvm::formatv("Message #{0}", Idx + 1);
    ThreadFlow Item = ThreadFlow::create()
                          .setRange(CSR)
                          .setImportance(Importances[Idx])
                          .setMessage(Message);
    Threadflows.push_back(Item);
  }

  // WHEN: A result containing code flows and diagnostic locations is added
  Writer.createRun("sarif test", "sarif test runner", "1.0.0");
  unsigned RuleIdx = Writer.createRule(Rule);
  const SarifResult &Result =
      SarifResult::create(RuleIdx)
          .setLocations({DiagLoc})
          .setDiagnosticMessage("Redefinition of 'foo'")
          .setThreadFlows(Threadflows)
          .setDiagnosticLevel(SarifResultLevel::Warning);
  Writer.appendResult(Result);
  std::string Output = serializeSarifDocument(Writer.createDocument());

  // THEN: Assert that the serialized SARIF is as expected
  ASSERT_THAT(Output, ::testing::StrEq(ExpectedOutput));
}

} // namespace