EnvUtilTest.cpp File Reference

#include <folly/experimental/EnvUtil.h>
#include <boost/algorithm/string.hpp>
#include <folly/Memory.h>
#include <folly/Subprocess.h>
#include <folly/portability/Fcntl.h>
#include <folly/portability/GTest.h>
#include <folly/portability/Stdlib.h>
#include <glog/logging.h>
#include <spawn.h>
#include <system_error>

Go to the source code of this file.

Functions
	DEFINE_string (env_util_subprocess_binary,"./env_util_subprocess","Location of the `env_util_subprocess` test helper program")
	TEST (EnvVarSaverTest, ExampleNew)
	TEST (EnvVarSaverTest, ExampleExisting)
	TEST (EnvVarSaverTest, Movable)
	TEST (EnvironmentStateTest, FailOnEmptyString)
	TEST (EnvironmentStateTest, MovableAndCopyable)
	TEST (EnvironmentStateTest, FailOnDuplicate)
	TEST (EnvironmentStateTest, Separation)
	TEST (EnvironmentStateTest, Update)
	TEST (EnvironmentStateTest, forSubprocess)
	TEST (EnvironmentStateTest, forC)
	TEST (EnvVarSaverTest, ExampleDeleting)

Function Documentation

DEFINE_string	(	env_util_subprocess_binary	,
		"./env_util_subprocess"	,
		"Location of the `env_util_subprocess` test helper program"
	)

TEST	(	EnvVarSaverTest	,
		ExampleNew
	)

Definition at line 39 of file EnvUtilTest.cpp.

References EXPECT_EQ, and EXPECT_STREQ.

                                  {
  auto key = "hahahahaha";
  EXPECT_EQ(nullptr, getenv(key));

  PCHECK(0 == setenv(key, "", true));
  EXPECT_STREQ("", getenv(key));
  PCHECK(0 == unsetenv(key));
  EXPECT_EQ(nullptr, getenv(key));

  auto saver = std::make_unique<EnvVarSaver>();
  PCHECK(0 == setenv(key, "blah", true));
  EXPECT_STREQ("blah", getenv(key));
  saver = nullptr;
  EXPECT_EQ(nullptr, getenv(key));
}

TEST	(	EnvVarSaverTest	,
		ExampleExisting
	)

Definition at line 55 of file EnvUtilTest.cpp.

References EXPECT_EQ, EXPECT_NE, EXPECT_STREQ, string, and folly::value().

                                       {
  auto key = "PATH";
  EXPECT_NE(nullptr, getenv(key));
  auto value = std::string{getenv(key)};

  auto saver = std::make_unique<EnvVarSaver>();
  PCHECK(0 == setenv(key, "blah", true));
  EXPECT_STREQ("blah", getenv(key));
  saver = nullptr;
  EXPECT_EQ(value, getenv(key));
}

TEST	(	EnvVarSaverTest	,
		Movable
	)

Definition at line 67 of file EnvUtilTest.cpp.

References folly::Optional< Value >::clear(), folly::Optional< Value >::emplace(), EXPECT_EQ, EXPECT_NE, EXPECT_STREQ, folly::gen::move, string, and folly::value().

                               {
  Optional<EnvVarSaver> pSaver1;
  pSaver1.emplace();
  auto key = "PATH";
  EXPECT_NE(nullptr, getenv(key));
  auto value = std::string{getenv(key)};
  Optional<EnvVarSaver> pSaver2;
  pSaver2.emplace(std::move(*pSaver1));
  pSaver1.clear();
  PCHECK(0 == setenv(key, "blah", true));
  EXPECT_STREQ("blah", getenv(key));
  pSaver2.clear();
  EXPECT_EQ(value, getenv(key));
}

TEST	(	EnvironmentStateTest	,
		FailOnEmptyString
	)

Definition at line 82 of file EnvUtilTest.cpp.

References EXPECT_THROW.

                                              {
  EnvVarSaver saver{};
  char test[4] = "A=B";
  PCHECK(0 == putenv(test));
  auto okState = EnvironmentState::fromCurrentEnvironment();
  test[0] = 0;
  EXPECT_THROW(
      EnvironmentState::fromCurrentEnvironment(), MalformedEnvironment);
}

TEST	(	EnvironmentStateTest	,
		MovableAndCopyable
	)

Definition at line 92 of file EnvUtilTest.cpp.

References folly::empty(), EXPECT_EQ, and folly::gen::move.

                                               {
  auto initialState = EnvironmentState::fromCurrentEnvironment();
  auto copiedState1 = EnvironmentState::empty();
  copiedState1.operator=(initialState);
  EnvironmentState copiedState2{initialState};
  EXPECT_EQ(*initialState, *copiedState1);
  EXPECT_EQ(*initialState, *copiedState2);
  (*initialState)["foo"] = "bar";
  EXPECT_EQ(0, copiedState1->count("foo"));
  EXPECT_EQ(0, copiedState2->count("foo"));
  auto movedState1 = EnvironmentState::empty();
  movedState1.operator=(std::move(copiedState1));
  EnvironmentState movedState2{std::move(copiedState2)};
  EXPECT_EQ(0, movedState1->count("foo"));
  EXPECT_EQ(0, movedState2->count("foo"));
  initialState->erase("foo");
  EXPECT_EQ(*initialState, *movedState1);
  EXPECT_EQ(*initialState, *movedState2);
}

TEST	(	EnvironmentStateTest	,
		FailOnDuplicate
	)

Definition at line 112 of file EnvUtilTest.cpp.

References EXPECT_THROW.

                                            {
  EnvVarSaver saver{};
  char test[7] = "PATG=B";
  PCHECK(0 == putenv(test));
  auto okState = EnvironmentState::fromCurrentEnvironment();
  test[3] = 'H';
  EXPECT_THROW(
      EnvironmentState::fromCurrentEnvironment(), MalformedEnvironment);
}

TEST	(	EnvironmentStateTest	,
		Separation
	)

Definition at line 122 of file EnvUtilTest.cpp.

References EXPECT_EQ, and EXPECT_STREQ.

                                       {
  EnvVarSaver saver{};
  auto initialState = EnvironmentState::fromCurrentEnvironment();
  PCHECK(0 == setenv("spork", "foon", true));
  auto updatedState = EnvironmentState::fromCurrentEnvironment();
  EXPECT_EQ(0, initialState->count("spork"));
  EXPECT_EQ(1, updatedState->count("spork"));
  EXPECT_EQ("foon", (*updatedState)["spork"]);
  updatedState->erase("spork");
  EXPECT_EQ(0, updatedState->count("spork"));
  EXPECT_STREQ("foon", getenv("spork"));
}

TEST	(	EnvironmentStateTest	,
		Update
	)

Definition at line 135 of file EnvUtilTest.cpp.

References EXPECT_EQ, and EXPECT_STREQ.

                                   {
  EnvVarSaver saver{};
  auto env = EnvironmentState::fromCurrentEnvironment();
  EXPECT_EQ(nullptr, getenv("spork"));
  (*env)["spork"] = "foon";
  EXPECT_EQ(nullptr, getenv("spork"));
  env.setAsCurrentEnvironment();
  EXPECT_STREQ("foon", getenv("spork"));
}

TEST	(	EnvironmentStateTest	,
		forSubprocess
	)

Definition at line 145 of file EnvUtilTest.cpp.

References folly::empty(), and EXPECT_EQ.

                                          {
  auto env = EnvironmentState::empty();
  (*env)["spork"] = "foon";
  std::vector<std::string> expected = {"spork=foon"};
  auto vec = env.toVector();
  EXPECT_EQ(expected, vec);
  Subprocess subProcess{{fLS::FLAGS_env_util_subprocess_binary},
                        {},
                        fLS::FLAGS_env_util_subprocess_binary.c_str(),
                        &vec};
  EXPECT_EQ(0, subProcess.wait().exitStatus());
}

TEST	(	EnvironmentStateTest	,
		forC
	)

Definition at line 158 of file EnvUtilTest.cpp.

References folly::empty(), EXPECT_EQ, and EXPECT_STREQ.

                                 {
  auto env = EnvironmentState::empty();
  (*env)["spork"] = "foon";
  EXPECT_STREQ("spork=foon", env.toPointerArray().get()[0]);
  EXPECT_EQ(nullptr, env.toPointerArray().get()[1]);
  char const* program = fLS::FLAGS_env_util_subprocess_binary.c_str();
  pid_t pid;
  PCHECK(
      0 ==
      posix_spawn(
          &pid,
          program,
          nullptr,
          nullptr,
          nullptr,
          env.toPointerArray().get()));
  int result;
  PCHECK(pid == waitpid(pid, &result, 0));
  EXPECT_EQ(0, result);
}

TEST	(	EnvVarSaverTest	,
		ExampleDeleting
	)

Definition at line 179 of file EnvUtilTest.cpp.

References EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, string, and folly::value().

                                       {
  auto key = "PATH";
  EXPECT_NE(nullptr, getenv(key));
  auto value = std::string{getenv(key)};

  auto saver = std::make_unique<EnvVarSaver>();
  PCHECK(0 == unsetenv(key));
  EXPECT_EQ(nullptr, getenv(key));
  saver = nullptr;
  EXPECT_TRUE(value == getenv(key));
}