def test_set_version_same(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test set_version same."""
version = mocker.patch.object(TFEnvManager, "version")
tfenv = TFEnvManager(tmp_path)
tfenv.current_version = "0.15.5"
assert not tfenv.set_version("0.15.5")
assert tfenv.current_version == "0.15.5"
assert tfenv.version == version
def test_install_no_version(self, tmp_path):
"""Test install with no version available."""
tfenv = TFEnvManager(tmp_path)
with pytest.raises(ValueError) as excinfo:
assert tfenv.install()
assert str(excinfo.value) == (
"version not provided and unable to find a .terraform-version file"
)
def test_parse_version_string_raise_value_error(self) -> None:
"""Test parse_version_string."""
with pytest.raises(
ValueError,
match=re.escape(
f"provided version doesn't conform to regex: {TFEnvManager.VERSION_REGEX}"
),
):
TFEnvManager.parse_version_string("0.15")
def test_get_version_from_executable_raise(self, fake_process: FakeProcess) -> None:
"""Test get_version_from_executable raise exception."""
fake_process.register_subprocess(
["usr/tfenv/terraform", "-version"], returncode=1
)
with pytest.raises(
subprocess.CalledProcessError, match="returned non-zero exit status 1"
):
TFEnvManager.get_version_from_executable("usr/tfenv/terraform")
def test_install_version_undefined(
self, mocker: MockerFixture, tmp_path: Path
) -> None:
"""Test install."""
mocker.patch.object(TFEnvManager, "version", None)
tfenv = TFEnvManager(tmp_path)
with pytest.raises(
ValueError, match=r"^version not provided and unable to find .*"
):
tfenv.install()
def test_set_version(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test set_version."""
version = VersionTuple(0, 15, 5)
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
mocker.patch.object(TFEnvManager, "get_version_from_file", return_value=None)
tfenv = TFEnvManager(tmp_path)
(tfenv.versions_dir / str(version)).mkdir()
assert not tfenv.current_version
assert not tfenv.set_version(str(version))
assert tfenv.version == version
assert tfenv.current_version == str(version)
def test_version_unavailable(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test version latest."""
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
mocker.patch(
f"{MODULE}.get_available_tf_versions",
return_value=["0.15.5", "0.15.4", "0.14.3", "0.14.2", "0.13.8"],
)
tfenv = TFEnvManager(tmp_path)
tfenv.current_version = "1.0.0"
with pytest.raises(SystemExit):
assert not tfenv.version
def test_install_already_installed(
self, mocker: MockerFixture, tmp_path: Path
) -> None:
"""Test install."""
version = VersionTuple(0, 15, 5)
mocker.patch.object(TFEnvManager, "version", version)
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
mock_download = mocker.patch(f"{MODULE}.download_tf_release")
tfenv = TFEnvManager(tmp_path)
(tfenv.versions_dir / str(version)).mkdir()
assert tfenv.install() == str(tfenv.bin)
mock_download.assert_not_called()
def test_install(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test install."""
version = VersionTuple(0, 15, 5)
mocker.patch.object(TFEnvManager, "version", version)
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
mock_download = mocker.patch(f"{MODULE}.download_tf_release")
tfenv = TFEnvManager(tmp_path)
(tfenv.versions_dir / "0.15.2").mkdir()
assert tfenv.install() == str(tfenv.bin)
mock_download.assert_called_once_with(
str(version), tfenv.versions_dir, tfenv.command_suffix
)
def test_install_unavailable(self, mock_download, mock_available_versions,
monkeypatch, tmp_path):
"""Test install."""
mock_available_versions.return_value = []
monkeypatch.setattr(TFEnvManager, "versions_dir", tmp_path)
tfenv = TFEnvManager(tmp_path)
with pytest.raises(SystemExit) as excinfo:
assert tfenv.install("0.12.0")
assert excinfo.value.code == 1
mock_available_versions.assert_called_once_with(True)
mock_download.assert_not_called()
assert not tfenv.current_version
def execute(self):
"""Execute tfenv."""
if self._cli_arguments.get('install'):
if self._cli_arguments.get('<tfenv-args>'):
TFEnvManager().install(
self._cli_arguments.get('<tfenv-args>')[0])
else:
TFEnvManager().install()
elif self._cli_arguments.get('run'):
cmd_line_args = strip_leading_option_delim(
self._cli_arguments.get('<tfenv-args>', []))
tf_bin = TFEnvManager().install()
sys.exit(subprocess.call([tf_bin] + cmd_line_args))
def test_install_set_version(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test install set version."""
version = VersionTuple(0, 15, 5)
mocker.patch.object(TFEnvManager, "version", version)
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
mock_download = mocker.patch(f"{MODULE}.download_tf_release")
mock_set_version = mocker.patch.object(
TFEnvManager, "set_version", return_value=None
)
tfenv = TFEnvManager(tmp_path)
assert tfenv.install(str(version))
mock_download.assert_called_once_with(
str(version), tfenv.versions_dir, tfenv.command_suffix
)
mock_set_version.assert_called_once_with(str(version))
def test_install_already_installed(self, mock_download,
mock_available_versions, monkeypatch,
tmp_path):
"""Test install with version already installed."""
mock_available_versions.return_value = ["0.12.0"]
monkeypatch.setattr(TFEnvManager, "versions_dir", tmp_path)
tfenv = TFEnvManager(tmp_path)
(tfenv.versions_dir / "0.12.0").mkdir()
assert tfenv.install("0.12.0")
mock_available_versions.assert_not_called()
mock_download.assert_not_called()
assert tfenv.current_version == "0.12.0"
assert tfenv.install(r"0\.12\..*") # regex does not match dir
def test_install_min_required(self, mock_download, mock_available_versions,
monkeypatch, tmp_path):
"""Test install min_required."""
mock_available_versions.return_value = ["0.12.0"]
monkeypatch.setattr(TFEnvManager, "versions_dir", tmp_path)
monkeypatch.setattr(TFEnvManager, "get_min_required",
MagicMock(return_value="0.12.0"))
tfenv = TFEnvManager(tmp_path)
assert tfenv.install("min-required")
mock_available_versions.assert_called_once_with(True)
mock_download.assert_called_once_with("0.12.0", tfenv.versions_dir,
tfenv.command_suffix)
assert tfenv.current_version == "0.12.0"
tfenv.get_min_required.assert_called_once_with() # pylint: disable=no-member
def test_install_unavailable(self, mocker: MockerFixture,
tmp_path: Path) -> None:
"""Test install."""
mock_available_versions = mocker.patch(
f"{MODULE}.get_available_tf_versions", return_value=[])
mock_download = mocker.patch(f"{MODULE}.download_tf_release")
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
tfenv = TFEnvManager(tmp_path)
with pytest.raises(SystemExit) as excinfo:
assert tfenv.install("0.12.0")
assert excinfo.value.code == 1
mock_available_versions.assert_called_once_with(True)
mock_download.assert_not_called()
assert not tfenv.current_version
def test_get_min_required(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test get_min_required."""
mocker.patch.object(TFEnvManager, "terraform_block", {})
tfenv = TFEnvManager(tmp_path)
with pytest.raises(SystemExit) as excinfo:
assert tfenv.get_min_required()
assert excinfo.value.code
mocker.patch.object(tfenv, "terraform_block", {"required_version": "!=0.12.0"})
with pytest.raises(SystemExit) as excinfo:
assert tfenv.get_min_required()
assert excinfo.value.code
mocker.patch.object(tfenv, "terraform_block", {"required_version": "~>0.12.0"})
assert tfenv.get_min_required() == "0.12.0"
def test_terraform_block(
self,
caplog: LogCaptureFixture,
expected: Dict[str, Any],
mocker: MockerFixture,
response: List[Any],
tmp_path: Path,
) -> None:
"""Test terraform_block."""
caplog.set_level(LogLevels.VERBOSE, logger=MODULE)
mock_load_terraform_module = mocker.patch(
f"{MODULE}.load_terraform_module", side_effect=response)
tfenv = TFEnvManager(tmp_path)
assert tfenv.terraform_block == expected
if not isinstance(response[0], dict):
assert "failed to parse as HCL2; trying HCL" in "\n".join(
caplog.messages)
mock_load_terraform_module.assert_has_calls(
[call(hcl2, tmp_path),
call(hcl, tmp_path)] # type: ignore
)
else:
mock_load_terraform_module.assert_called_once_with(hcl2, tmp_path)
def test_install_already_installed(self, mocker: MockerFixture,
tmp_path: Path) -> None:
"""Test install with version already installed."""
mock_available_versions = mocker.patch(
f"{MODULE}.get_available_tf_versions", return_value=["0.12.0"])
mock_download = mocker.patch(f"{MODULE}.download_tf_release")
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
tfenv = TFEnvManager(tmp_path)
(tfenv.versions_dir / "0.12.0").mkdir()
assert tfenv.install("0.12.0")
mock_available_versions.assert_not_called()
mock_download.assert_not_called()
assert tfenv.current_version == "0.12.0"
assert tfenv.install(r"0\.12\..*") # regex does not match dir
def test_get_version_from_file(self, tmp_path):
"""Test get_version_from_file."""
tfenv = TFEnvManager(tmp_path)
# no version file or path
assert not tfenv.get_version_from_file()
del tfenv.version_file
# path provided
version_file = tmp_path / ".version"
version_file.write_text(six.u("0.11.5"))
assert tfenv.get_version_from_file(version_file) == "0.11.5"
# path not provided; use version file
version_file = tmp_path / TF_VERSION_FILENAME
version_file.write_text(six.u("0.12.0"))
assert tfenv.get_version_from_file(version_file) == "0.12.0"
def test_install_min_required(self, mocker: MockerFixture,
tmp_path: Path) -> None:
"""Test install min_required."""
mock_available_versions = mocker.patch(
f"{MODULE}.get_available_tf_versions", return_value=["0.12.0"])
mock_download = mocker.patch(f"{MODULE}.download_tf_release")
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
mocker.patch.object(TFEnvManager, "get_min_required",
MagicMock(return_value="0.12.0"))
tfenv = TFEnvManager(tmp_path)
assert tfenv.install("min-required")
mock_available_versions.assert_called_once_with(True)
mock_download.assert_called_once_with("0.12.0", tfenv.versions_dir,
tfenv.command_suffix)
assert tfenv.current_version == "0.12.0"
tfenv.get_min_required.assert_called_once_with() # pylint: disable=no-member
def test_version(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test version."""
version = VersionTuple(0, 15, 5)
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
mock_get_available_tf_versions = mocker.patch(
f"{MODULE}.get_available_tf_versions", return_value=[]
)
mock_get_version_from_file = mocker.patch.object(
TFEnvManager, "get_version_from_file", return_value=None
)
tfenv = TFEnvManager(tmp_path)
(tfenv.versions_dir / str(version)).mkdir()
tfenv.current_version = str(version)
assert tfenv.version == version
assert tfenv.current_version == str(version)
mock_get_version_from_file.assert_not_called()
mock_get_available_tf_versions.assert_not_called()
def test_get_min_required(self, monkeypatch, tmp_path):
"""Test get_min_required."""
monkeypatch.setattr(TFEnvManager, "terraform_block", {})
tfenv = TFEnvManager(tmp_path)
with pytest.raises(SystemExit) as excinfo:
assert tfenv.get_min_required()
assert excinfo.value.code
monkeypatch.setattr(tfenv, "terraform_block",
{"required_version": "!=0.12.0"})
with pytest.raises(SystemExit) as excinfo:
assert tfenv.get_min_required()
assert excinfo.value.code
monkeypatch.setattr(tfenv, "terraform_block",
{"required_version": "~>0.12.0"})
assert tfenv.get_min_required() == "0.12.0"
def test_install_latest(self, mock_download, mock_available_versions,
monkeypatch, tmp_path):
"""Test install latest."""
mock_available_versions.return_value = ["0.12.0", "0.11.5"]
monkeypatch.setattr(TFEnvManager, "versions_dir", tmp_path)
tfenv = TFEnvManager(tmp_path)
assert tfenv.install("latest")
mock_available_versions.assert_called_once_with(False)
mock_download.assert_called_once_with("0.12.0", tfenv.versions_dir,
tfenv.command_suffix)
assert tfenv.current_version == "0.12.0"
assert tfenv.install("latest:0.11.5")
mock_available_versions.assert_called_with(False)
mock_download.assert_called_with("0.11.5", tfenv.versions_dir,
tfenv.command_suffix)
assert tfenv.current_version == "0.11.5"
def test_version_undefined(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test version not specified."""
mock_get_version_from_file = mocker.patch.object(
TFEnvManager, "get_version_from_file", return_value=None
)
tfenv = TFEnvManager(tmp_path)
assert tfenv.version is None
assert tfenv.current_version is None
mock_get_version_from_file.assert_called_once_with()
def test_install(self, mock_download, mock_available_versions, monkeypatch,
tmp_path):
"""Test install."""
mock_available_versions.return_value = ["0.12.0", "0.11.5"]
monkeypatch.setattr(TFEnvManager, "versions_dir", tmp_path)
monkeypatch.setattr(TFEnvManager, "get_version_from_file",
MagicMock(return_value="0.11.5"))
tfenv = TFEnvManager(tmp_path)
assert tfenv.install("0.12.0")
mock_available_versions.assert_called_once_with(True)
mock_download.assert_called_once_with("0.12.0", tfenv.versions_dir,
tfenv.command_suffix)
assert tfenv.current_version == "0.12.0"
assert tfenv.install()
mock_download.assert_called_with("0.11.5", tfenv.versions_dir,
tfenv.command_suffix)
assert tfenv.current_version == "0.11.5"
def test_backend(
self,
mocker: MockerFixture,
response: Dict[str, Any],
expected: Dict[str, Any],
tmp_path: Path,
) -> None:
"""Test backend."""
mocker.patch(f"{MODULE}.load_terraform_module", return_value=response)
tfenv = TFEnvManager(tmp_path)
assert tfenv.backend == expected
def test_install_latest(self, mocker: MockerFixture,
tmp_path: Path) -> None:
"""Test install latest."""
mock_available_versions = mocker.patch(
f"{MODULE}.get_available_tf_versions",
return_value=["0.12.0", "0.11.5"])
mock_download = mocker.patch(f"{MODULE}.download_tf_release")
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
tfenv = TFEnvManager(tmp_path)
assert tfenv.install("latest")
mock_available_versions.assert_called_once_with(False)
mock_download.assert_called_once_with("0.12.0", tfenv.versions_dir,
tfenv.command_suffix)
assert tfenv.current_version == "0.12.0"
assert tfenv.install("latest:0.11.5")
mock_available_versions.assert_called_with(False)
mock_download.assert_called_with("0.11.5", tfenv.versions_dir,
tfenv.command_suffix)
assert tfenv.current_version == "0.11.5"
def test_get_version_from_executable(
self,
expected: Optional[VersionTuple],
fake_process: FakeProcess,
output: str,
) -> None:
"""Test get_version_from_executable."""
fake_process.register_subprocess(
["usr/tfenv/terraform", "-version"], stdout=output
)
assert (
TFEnvManager.get_version_from_executable("usr/tfenv/terraform") == expected
)
def test_version_latest(self, mocker: MockerFixture, tmp_path: Path) -> None:
"""Test version latest."""
version = VersionTuple(0, 15, 5)
mocker.patch.object(TFEnvManager, "versions_dir", tmp_path)
mock_get_available_tf_versions = mocker.patch(
f"{MODULE}.get_available_tf_versions", return_value=["0.15.5", "0.15.4"]
)
mock_get_version_from_file = mocker.patch.object(
TFEnvManager, "get_version_from_file", return_value="latest"
)
tfenv = TFEnvManager(tmp_path)
assert tfenv.version == version
assert tfenv.current_version == str(version)
mock_get_version_from_file.assert_called_once_with()
mock_get_available_tf_versions.assert_called_once_with(False)
def test_terraform_block(self, mock_load_terrafrom_module, response,
expected, caplog, tmp_path):
"""Test terraform_block."""
caplog.set_level(LogLevels.VERBOSE, logger=MODULE)
mock_load_terrafrom_module.side_effect = response
tfenv = TFEnvManager(tmp_path)
assert tfenv.terraform_block == expected
if not isinstance(response[0], dict):
assert "failed to parse as HCL2; trying HCL" in "\n".join(
caplog.messages)
mock_load_terrafrom_module.assert_has_calls(
[call(hcl2, tmp_path),
call(hcl, tmp_path)])
else:
mock_load_terrafrom_module.assert_called_once_with(hcl2, tmp_path)
