test: run tests in build dir, pass source dir in env

This works around an annoyance with gtest_discover_tests.
The test discovery system works by running the test binary with flags
to make it produce a JSON file that gives details of all the tests.
However, that file is written to the working directory. If we set the
working directory for the tests to be the source directory, then
the tests can access their test data by relative paths, but the
JSON test details files for test discovery get written to the
source directory, which is ugly.

So, we instead provide the location of the source tree through an
environment variable, and then in the tests themselves we change
the current working directory to the source tree directory.

Why change CWD instead of just using absolute paths for input files?
Because error messages produced by jsonnet include the file paths,
and we need (or at least want) those to still be relative paths so
that we can compare against stable golden outputs.

Author: johnbartholomew

CMakeLists.txt

@@ -308,9 +308,10 @@ if(BUILD_TESTS)
         add_executable(${TESTNAME} ${ARGN})
         target_link_libraries(${TESTNAME} ${JSONNET_LIB_TARGET} gtest gmock gtest_main)
         gtest_discover_tests(${TESTNAME}
-            # Test-data is in the source directory so that's where we run the test.
-            WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-            PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+            PROPERTIES
+                VS_DEBUGGER_WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
+                ENVIRONMENT "JSONNET_SOURCE_BASE=${PROJECT_SOURCE_DIR}"
         )
         set_target_properties(${TESTNAME} PROPERTIES FOLDER tests)
     endfunction()

core/libjsonnet_test.cpp

@@ -18,12 +18,36 @@ extern "C" {
 #include "libjsonnet.h"
 }
 
+#include <cstdlib>
+#include <filesystem>
+
 #include "gtest/gtest.h"
 
 namespace jsonnet::internal {
 namespace {
 
-TEST(JsonnetTest, TestEvaluateSnippet)
+class TestInSourceDir : public testing::Test {
+    protected:
+        static void SetUpTestSuite() {
+            original_cwd_ = std::filesystem::current_path();
+            const char* source_base_env = std::getenv("JSONNET_SOURCE_BASE");
+            if (source_base_env) {
+                std::filesystem::path source_base{source_base_env};
+                std::filesystem::current_path(source_base);
+            }
+        }
+
+        static void TearDownTestSuite() {
+            std::filesystem::current_path(original_cwd_);
+        }
+
+    private:
+        static std::filesystem::path original_cwd_;
+};
+
+std::filesystem::path TestInSourceDir::original_cwd_;
+
+TEST_F(TestInSourceDir, TestEvaluateSnippet)
 {
     const char* snippet = "std.assertEqual(({ x: 1, y: self.x } { x: 2 }).y, 2)";
     struct JsonnetVm* vm = jsonnet_make();
@@ -35,13 +59,12 @@ TEST(JsonnetTest, TestEvaluateSnippet)
     jsonnet_destroy(vm);
 }
 
-TEST(JsonnetTest, TestEvaluateFile)
+TEST_F(TestInSourceDir, TestEvaluateFile)
 {
-    const char* file_path = "test_suite/object.jsonnet";
     struct JsonnetVm *vm = jsonnet_make();
     ASSERT_FALSE(vm == nullptr);
     int error = 0;
-    char* output = jsonnet_evaluate_file(vm, file_path, &error);
+    char* output = jsonnet_evaluate_file(vm, "test_suite/object.jsonnet", &error);
     EXPECT_EQ(0, error);
     EXPECT_STREQ("true\n", output);
     jsonnet_realloc(vm, output, 0);

cpp/libjsonnet++_test.cpp

@@ -16,24 +16,48 @@ limitations under the License.
 
 #include "libjsonnet++.h"
 
+#include <cstdlib>
+#include <filesystem>
 #include <fstream>
 #include <streambuf>
 #include <string>
 
 #include "gtest/gtest.h"
 
 namespace jsonnet {
-std::string readFile(const std::string& filename)
+
+class TestInSourceDir : public testing::Test {
+    protected:
+        static void SetUpTestSuite() {
+            original_cwd_ = std::filesystem::current_path();
+            const char* source_base_env = std::getenv("JSONNET_SOURCE_BASE");
+            if (source_base_env) {
+                std::filesystem::path source_base{source_base_env};
+                std::filesystem::current_path(source_base);
+            }
+        }
+
+        static void TearDownTestSuite() {
+            std::filesystem::current_path(original_cwd_);
+        }
+
+    private:
+        static std::filesystem::path original_cwd_;
+};
+
+std::filesystem::path TestInSourceDir::original_cwd_;
+
+std::string readFile(const std::string& path)
 {
-    std::ifstream in(filename);
+    std::ifstream in(path);
     if (!in.good()){
-        ADD_FAILURE() << "Could not open: " << filename;
+        ADD_FAILURE() << "Could not open: " << path;
         return "";
     }
     return std::string(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>());
 }
 
-TEST(JsonnetTest, TestEvaluateSnippet)
+TEST_F(TestInSourceDir, TestEvaluateSnippet)
 {
     const std::string input = readFile("cpp/testdata/example.jsonnet");
     const std::string expected = readFile("cpp/testdata/example_golden.json");
@@ -46,7 +70,7 @@ TEST(JsonnetTest, TestEvaluateSnippet)
     EXPECT_EQ("", jsonnet.lastError());
 }
 
-TEST(JsonnetTest, TestEvaluateInvalidSnippet)
+TEST_F(TestInSourceDir, TestEvaluateInvalidSnippet)
 {
     const std::string input = readFile("cpp/testdata/invalid.jsonnet");
     const std::string error = readFile("cpp/testdata/invalid.out");
@@ -59,7 +83,7 @@ TEST(JsonnetTest, TestEvaluateInvalidSnippet)
     EXPECT_EQ(error, jsonnet.lastError());
 }
 
-TEST(JsonnetTest, TestEvaluateFile)
+TEST_F(TestInSourceDir, TestEvaluateFile)
 {
     const std::string expected = readFile("cpp/testdata/example_golden.json");
 
@@ -71,7 +95,7 @@ TEST(JsonnetTest, TestEvaluateFile)
     EXPECT_EQ("", jsonnet.lastError());
 }
 
-TEST(JsonnetTest, TestEvaluateInvalidFile)
+TEST_F(TestInSourceDir, TestEvaluateInvalidFile)
 {
     const std::string expected = readFile("cpp/testdata/invalid.out");
 
@@ -83,7 +107,7 @@ TEST(JsonnetTest, TestEvaluateInvalidFile)
     EXPECT_EQ(expected, jsonnet.lastError());
 }
 
-TEST(JsonnetTest, TestAddImportPath)
+TEST_F(TestInSourceDir, TestAddImportPath)
 {
     const std::string expected = readFile("cpp/testdata/importing_golden.json");