blob: 3d5a198c7d1f1772c97b4240dac1974b606671f6 [file] [log] [blame] [edit]
# Copyright 2019 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Unit tests for unittest.bzl."""
load("//lib:unittest.bzl", "analysistest", "asserts", "unittest")
###################################
####### fail_basic_test ###########
###################################
def _basic_failing_test(ctx):
"""Unit tests for a basic library verification test that fails."""
env = unittest.begin(ctx)
asserts.equals(env, 1, 2)
return unittest.end(env)
basic_failing_test = unittest.make(_basic_failing_test)
###################################
####### basic_passing_test ########
###################################
def _basic_passing_test(ctx):
"""Unit tests for a basic library verification test."""
env = unittest.begin(ctx)
asserts.equals(env, 1, 1)
return unittest.end(env)
basic_passing_test = unittest.make(_basic_passing_test)
###################################
####### change_setting_test #######
###################################
def _change_setting_test(ctx):
"""Test to verify that an analysis test may change configuration."""
env = analysistest.begin(ctx)
dep_min_os_version = analysistest.target_under_test(env)[_ChangeSettingInfo].min_os_version
asserts.equals(env, "1234.5678", dep_min_os_version)
return analysistest.end(env)
_ChangeSettingInfo = provider()
def _change_setting_fake_rule(ctx):
return [_ChangeSettingInfo(min_os_version = ctx.fragments.cpp.minimum_os_version())]
change_setting_fake_rule = rule(
implementation = _change_setting_fake_rule,
fragments = ["cpp"],
)
change_setting_test = analysistest.make(
_change_setting_test,
config_settings = {
"//command_line_option:minimum_os_version": "1234.5678",
},
)
####################################
####### failure_testing_test #######
####################################
def _failure_testing_test(ctx):
"""Test to verify that an analysis test may verify a rule fails with fail()."""
env = analysistest.begin(ctx)
asserts.expect_failure(env, "This rule should never work")
return analysistest.end(env)
def _failure_testing_fake_rule(ctx):
ignore = [ctx]
fail("This rule should never work")
failure_testing_fake_rule = rule(
implementation = _failure_testing_fake_rule,
)
failure_testing_test = analysistest.make(
_failure_testing_test,
expect_failure = True,
)
############################################
####### fail_unexpected_passing_test #######
############################################
def _fail_unexpected_passing_test(ctx):
"""Test that fails by expecting an error that never occurs."""
env = analysistest.begin(ctx)
asserts.expect_failure(env, "Oh no, going to fail")
return analysistest.end(env)
def _fail_unexpected_passing_fake_rule(ctx):
_ignore = [ctx]
return []
fail_unexpected_passing_fake_rule = rule(
implementation = _fail_unexpected_passing_fake_rule,
)
fail_unexpected_passing_test = analysistest.make(
_fail_unexpected_passing_test,
expect_failure = True,
)
################################################
####### change_setting_with_failure_test #######
################################################
def _change_setting_with_failure_test(ctx):
"""Test verifying failure while changing configuration."""
env = analysistest.begin(ctx)
asserts.expect_failure(env, "unexpected minimum_os_version!!!")
return analysistest.end(env)
def _change_setting_with_failure_fake_rule(ctx):
if ctx.fragments.cpp.minimum_os_version() == "error_error":
fail("unexpected minimum_os_version!!!")
return []
change_setting_with_failure_fake_rule = rule(
implementation = _change_setting_with_failure_fake_rule,
fragments = ["cpp"],
)
change_setting_with_failure_test = analysistest.make(
_change_setting_with_failure_test,
expect_failure = True,
config_settings = {
"//command_line_option:minimum_os_version": "error_error",
},
)
####################################
####### inspect_actions_test #######
####################################
def _inspect_actions_test(ctx):
"""Test verifying actions registered by a target."""
env = analysistest.begin(ctx)
actions = analysistest.target_actions(env)
asserts.equals(env, 1, len(actions))
action_output = actions[0].outputs.to_list()[0]
asserts.equals(env, "out.txt", action_output.basename)
return analysistest.end(env)
def _inspect_actions_fake_rule(ctx):
out_file = ctx.actions.declare_file("out.txt")
ctx.actions.run_shell(
command = "echo 'hello' > %s" % out_file.basename,
outputs = [out_file],
)
return [DefaultInfo(files = depset([out_file]))]
inspect_actions_fake_rule = rule(
implementation = _inspect_actions_fake_rule,
)
inspect_actions_test = analysistest.make(
_inspect_actions_test,
)
########################################
####### inspect_output_dirs_test #######
########################################
_OutputDirInfo = provider(fields = ["bin_path"])
def _inspect_output_dirs_test(ctx):
"""Test verifying output directories used by a test."""
env = analysistest.begin(ctx)
# Assert that the output bin dir observed by the aspect added by analysistest
# is the same as those observed by the rule directly, even when that's
# under a config transition and therefore not the same as the bin dir
# used by the test rule.
bin_path = analysistest.target_bin_dir_path(env)
target_under_test = analysistest.target_under_test(env)
asserts.false(env, not bin_path, "bin dir path not found.")
asserts.false(
env,
bin_path == ctx.bin_dir.path,
"test bin dir (%s) expected to differ with target_under_test bin dir (%s)." % (bin_path, ctx.bin_dir.path),
)
asserts.equals(env, bin_path, target_under_test[_OutputDirInfo].bin_path)
return analysistest.end(env)
def _inspect_output_dirs_fake_rule(ctx):
return [
_OutputDirInfo(
bin_path = ctx.bin_dir.path,
),
]
inspect_output_dirs_fake_rule = rule(
implementation = _inspect_output_dirs_fake_rule,
)
inspect_output_dirs_test = analysistest.make(
_inspect_output_dirs_test,
# The output directories differ between the test and target under test when
# the target under test is under a config transition.
config_settings = {
"//command_line_option:minimum_os_version": "1234.5678",
},
)
#########################################
# buildifier: disable=unnamed-macro
def unittest_passing_tests_suite():
"""Creates the test targets and test suite for passing unittest.bzl tests.
Not all tests are included. Some unittest.bzl tests verify a test fails
when assertions are not met. Such tests must be run in an e2e shell test.
This suite only includes tests which verify success tests.
"""
unittest.suite(
"unittest_tests",
basic_passing_test,
)
change_setting_test(
name = "change_setting_test",
target_under_test = ":change_setting_fake_target",
)
change_setting_fake_rule(
name = "change_setting_fake_target",
tags = ["manual"],
)
failure_testing_test(
name = "failure_testing_test",
target_under_test = ":failure_testing_fake_target",
)
failure_testing_fake_rule(
name = "failure_testing_fake_target",
tags = ["manual"],
)
change_setting_with_failure_test(
name = "change_setting_with_failure_test",
target_under_test = ":change_setting_with_failure_fake_target",
)
change_setting_with_failure_fake_rule(
name = "change_setting_with_failure_fake_target",
tags = ["manual"],
)
inspect_actions_test(
name = "inspect_actions_test",
target_under_test = ":inspect_actions_fake_target",
)
inspect_actions_fake_rule(
name = "inspect_actions_fake_target",
tags = ["manual"],
)
inspect_output_dirs_test(
name = "inspect_output_dirs_test",
target_under_test = ":inspect_output_dirs_fake_target",
)
inspect_output_dirs_fake_rule(
name = "inspect_output_dirs_fake_target",
tags = ["manual"],
)