# Copyright 2018 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 maprule.bzl."""

load("//lib:unittest.bzl", "asserts", "unittest")
load("//rules/private:maprule_testing.bzl", "maprule_testing")

def _dummy_generating_action(ctx, path):
    ctx.actions.write(path, "hello")

def _mock_file(ctx, path):
    f = ctx.actions.declare_file(path)
    _dummy_generating_action(ctx, f)
    return f

def _lstrip_until(s, until):
    return s[s.find(until):]

def _assert_dict_keys(env, expected, actual, msg):
    asserts.equals(env, {k: None for k in expected}, {k: None for k in actual}, msg)

def _assert_ends_with(env, expected_ending, s, msg):
    if not s.endswith(expected_ending):
        unittest.fail(env, msg + ": expected \"%s\" to end with \"%s\"" % (s, expected_ending))

def _assert_no_error(env, errors, msg):
    if errors:
        unittest.fail(env, msg + ": expected no errors, got: [%s]" % "\n".join(errors))

def _assert_error(env, errors, expected_fragment, msg):
    for e in errors:
        if expected_fragment in e:
            return
    unittest.fail(env, msg + ": did not find \"%s\" in: [%s]" % (expected_fragment, "\n".join(errors)))

def _contains_substrings_in_order(s, substrings):
    index = 0
    for ss in substrings:
        index = s.find(ss, index)
        if index < 0:
            return False
        index += len(ss)
    return True

def _assert_error_fragments(env, errors, expected_fragments, msg):
    for e in errors:
        if _contains_substrings_in_order(e, expected_fragments):
            return
    unittest.fail(env, msg + ": did not find expected fragments in \"%s\" in order" % "\n".join(errors))

def _src_placeholders_test(ctx):
    env = unittest.begin(ctx)

    for language, strategy in [
        ("cmd", maprule_testing.cmd_strategy),
        ("bash", maprule_testing.bash_strategy),
    ]:
        for basename, basename_noext in [("bar.txt", "bar"), ("bar.pb.h", "bar.pb")]:
            actual = maprule_testing.src_placeholders(
                _mock_file(ctx, language + "/foo/" + basename),
                strategy,
            )
            _assert_dict_keys(
                env,
                ["src", "src_dir", "src_name", "src_name_noext"],
                actual,
                "assertion #1 (language: %s, basename: %s)" % (language, basename),
            )
            _assert_ends_with(
                env,
                strategy.as_path(language + "/foo/" + basename),
                actual["src"],
                "assertion #2 (language: %s, basename: %s)" % (language, basename),
            )
            _assert_ends_with(
                env,
                strategy.as_path(language + "/foo/"),
                actual["src_dir"],
                "assertion #3 (language: %s, basename: %s)" % (language, basename),
            )
            asserts.equals(
                env,
                basename,
                actual["src_name"],
                "assertion #4 (language: %s, basename: %s)" % (language, basename),
            )
            asserts.equals(
                env,
                basename_noext,
                actual["src_name_noext"],
                "assertion #5 (language: %s, basename: %s)" % (language, basename),
            )

    return unittest.end(env)

src_placeholders_test = unittest.make(_src_placeholders_test)

def _validate_attributes_test(ctx):
    """Unit tests for maprule_testing.validate_attributes."""
    env = unittest.begin(ctx)
    _assert_no_error(
        env,
        maprule_testing.validate_attributes({"FOO": "bar"}, {"BAR": "value1"}),
        "assertion #1",
    )
    _assert_no_error(
        env,
        maprule_testing.validate_attributes({"FOO": "bar"}, {}),
        "assertion #2",
    )

    _assert_error(
        env,
        maprule_testing.validate_attributes({}, {}),
        "\"outs_templates\" must not be empty",
        "assertion #3",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"": "foo"}, {}),
        "name should not be empty",
        "assertion #4",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"foo": "bar"}, {}),
        "name should be all upper-case",
        "assertion #5",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"SRC": "bar"}, {}),
        "conflicting with the environment variable of the source file",
        "assertion #6",
    )

    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": ""}, {}),
        "output path should not be empty",
        "assertion #7",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": "/usr/bin"}, {}),
        "output path should be relative",
        "assertion #8",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": "c:/usr/bin"}, {}),
        "output path should be relative",
        "assertion #9",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": "../foo"}, {}),
        "output path should not contain uplevel references",
        "assertion #10",
    )
    _assert_no_error(
        env,
        maprule_testing.validate_attributes({"FOO": "./foo"}, {}),
        "assertion #11",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"BAR": "foo", "FOO": "foo"}, {}),
        "output path is already used for \"BAR\"",
        "assertion #12",
    )

    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": "bar"}, {"": "baz"}),
        "name should not be empty",
        "assertion #13",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": "bar"}, {"Bar": "baz"}),
        "name should be all upper-case",
        "assertion #14",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": "bar"}, {"FOO": "baz"}),
        "conflicting with the environment variable of the \"FOO\" output file",
        "assertion #15",
    )

    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": "bar"}, {"BAR": "$(location x) $(location y)"}),
        "use only one $(location)",
        "assertion #16",
    )
    _assert_error(
        env,
        maprule_testing.validate_attributes({"FOO": "bar"}, {"BAR": "a $(location b"}),
        "missing closing parenthesis",
        "assertion #17",
    )

    return unittest.end(env)

validate_attributes_test = unittest.make(_validate_attributes_test)

def _as_path_test(ctx):
    """Unit tests for maprule_testing.as_path."""
    env = unittest.begin(ctx)
    asserts.equals(
        env,
        "Foo\\Bar\\Baz\\Qux",
        maprule_testing.cmd_strategy.as_path("Foo/Bar/Baz\\Qux"),
        msg = "assertion #1",
    )
    asserts.equals(
        env,
        "Foo/Bar/Baz\\Qux",
        maprule_testing.bash_strategy.as_path("Foo/Bar/Baz\\Qux"),
        msg = "assertion #2",
    )
    return unittest.end(env)

as_path_test = unittest.make(_as_path_test)

def _assert_relative_path(env, path, index):
    asserts.true(
        env,
        maprule_testing.is_relative_path(path),
        msg = "assertion #%d" % index,
    )

def _assert_not_relative_path(env, path, index):
    asserts.false(
        env,
        maprule_testing.is_relative_path(path),
        msg = "assertion #%d" % index,
    )

def _is_relative_path_test(ctx):
    """Unit tests for maprule_testing.is_relative_path."""
    env = unittest.begin(ctx)
    _assert_relative_path(env, "Foo/Bar/Baz", 1)
    _assert_relative_path(env, "Foo\\Bar\\Baz", 2)
    _assert_relative_path(env, "Foo/Bar\\Baz", 3)
    _assert_not_relative_path(env, "d:/Foo/Bar", 4)
    _assert_not_relative_path(env, "D:/Foo/Bar", 5)
    _assert_not_relative_path(env, "/Foo/Bar", 6)
    _assert_not_relative_path(env, "\\Foo\\Bar", 7)
    return unittest.end(env)

is_relative_path_test = unittest.make(_is_relative_path_test)

def _custom_envmap_test(ctx):
    """Unit tests for maprule_testing.custom_envmap."""
    env = unittest.begin(ctx)

    actual = {}

    for language, strategy in [
        ("cmd", maprule_testing.cmd_strategy),
        ("bash", maprule_testing.bash_strategy),
    ]:
        actual[language] = maprule_testing.custom_envmap(
            ctx,
            strategy,
            src_placeholders = {"src_ph1": "Src/Ph1-value", "src_ph2": "Src/Ph2-value"},
            outs_dict = {
                "out1": _mock_file(ctx, language + "/Foo/Out1"),
                "out2": _mock_file(ctx, language + "/Foo/Out2"),
            },
            resolved_add_env = {"ENV1": "Env1"},
        )
        _assert_dict_keys(
            env,
            ["MAPRULE_SRC_PH1", "MAPRULE_SRC_PH2", "MAPRULE_OUT1", "MAPRULE_OUT2", "MAPRULE_ENV1"],
            actual[language],
            msg = "assertion #1 (language: %s)" % language,
        )
        actual[language]["MAPRULE_OUT1"] = _lstrip_until(actual[language]["MAPRULE_OUT1"], "Foo")
        actual[language]["MAPRULE_OUT2"] = _lstrip_until(actual[language]["MAPRULE_OUT2"], "Foo")

    asserts.equals(
        env,
        {
            "MAPRULE_ENV1": "Env1",
            "MAPRULE_OUT1": "Foo\\Out1",
            "MAPRULE_OUT2": "Foo\\Out2",
            "MAPRULE_SRC_PH1": "Src\\Ph1-value",
            "MAPRULE_SRC_PH2": "Src\\Ph2-value",
        },
        actual["cmd"],
        msg = "assertion #2",
    )

    asserts.equals(
        env,
        {
            "MAPRULE_ENV1": "Env1",
            "MAPRULE_OUT1": "Foo/Out1",
            "MAPRULE_OUT2": "Foo/Out2",
            "MAPRULE_SRC_PH1": "Src/Ph1-value",
            "MAPRULE_SRC_PH2": "Src/Ph2-value",
        },
        actual["bash"],
        msg = "assertion #3",
    )

    return unittest.end(env)

custom_envmap_test = unittest.make(_custom_envmap_test)

def _create_outputs_test(ctx):
    """Unit tests for maprule_testing.create_outputs."""
    env = unittest.begin(ctx)

    for language, strategy in [
        ("cmd", maprule_testing.cmd_strategy),
        ("bash", maprule_testing.bash_strategy),
    ]:
        src1 = _mock_file(ctx, language + "/foo/src1.txt")
        src2 = _mock_file(ctx, language + "/foo/src2.pb.h")
        src3 = _mock_file(ctx, language + "/bar/src1.txt")
        foreach_srcs = [src1, src2, src3]

        outs_dicts, all_output_files, _, errors = (
            maprule_testing.create_outputs(
                ctx,
                "my_maprule",
                {
                    "OUT1": "{src}.out1",
                    "OUT2": "{src_dir}/out2/{src_name_noext}.out2",
                },
                strategy,
                foreach_srcs,
            )
        )

        _assert_no_error(env, errors, "assertion #1 (language: %s)" % language)

        for output in all_output_files:
            _dummy_generating_action(ctx, output)

        _assert_dict_keys(
            env,
            foreach_srcs,
            outs_dicts,
            "assertion #2 (language: %s)" % language,
        )
        for src in foreach_srcs:
            _assert_dict_keys(
                env,
                ["OUT1", "OUT2"],
                outs_dicts[src],
                "assertion #3 (language: %s, src: %s)" % (language, src),
            )

        _assert_ends_with(
            env,
            "my_maprule_out/tests/%s/foo/src1.txt.out1" % language,
            outs_dicts[src1]["OUT1"].path,
            "assertion #4 (language: %s)" % language,
        )
        _assert_ends_with(
            env,
            "my_maprule_out/tests/%s/foo/out2/src1.out2" % language,
            outs_dicts[src1]["OUT2"].path,
            "assertion #5 (language: %s)" % language,
        )

        _assert_ends_with(
            env,
            "my_maprule_out/tests/%s/foo/src2.pb.h.out1" % language,
            outs_dicts[src2]["OUT1"].path,
            "assertion #6 (language: %s)" % language,
        )
        _assert_ends_with(
            env,
            "my_maprule_out/tests/%s/foo/out2/src2.pb.out2" % language,
            outs_dicts[src2]["OUT2"].path,
            "assertion #7 (language: %s)" % language,
        )

        _assert_ends_with(
            env,
            "my_maprule_out/tests/%s/bar/src1.txt.out1" % language,
            outs_dicts[src3]["OUT1"].path,
            "assertion #8 (language: %s)" % language,
        )
        _assert_ends_with(
            env,
            "my_maprule_out/tests/%s/bar/out2/src1.out2" % language,
            outs_dicts[src3]["OUT2"].path,
            "assertion #9 (language: %s)" % language,
        )

        expected = [
            "my_maprule_out/tests/%s/foo/src1.txt.out1" % language,
            "my_maprule_out/tests/%s/foo/out2/src1.out2" % language,
            "my_maprule_out/tests/%s/foo/src2.pb.h.out1" % language,
            "my_maprule_out/tests/%s/foo/out2/src2.pb.out2" % language,
            "my_maprule_out/tests/%s/bar/src1.txt.out1" % language,
            "my_maprule_out/tests/%s/bar/out2/src1.out2" % language,
        ]
        for i in range(0, len(all_output_files)):
            actual = _lstrip_until(all_output_files[i].path, "my_maprule_out")
            asserts.equals(
                env,
                expected[i],
                actual,
                "assertion #10 (language: %s, index: %d)" % (language, i),
            )

    return unittest.end(env)

create_outputs_test = unittest.make(_create_outputs_test)

def _conflicting_outputs_test(ctx):
    """Unit tests for maprule_testing.create_outputs catching conflicting outputs."""
    env = unittest.begin(ctx)

    for language, strategy in [
        ("cmd", maprule_testing.cmd_strategy),
        ("bash", maprule_testing.bash_strategy),
    ]:
        src1 = _mock_file(ctx, language + "/foo/src1.txt")
        src2 = _mock_file(ctx, language + "/foo/src2.pb.h")
        src3 = _mock_file(ctx, language + "/bar/src1.txt")
        foreach_srcs = [src1, src2, src3]

        _, all_output_files, _, errors = (
            maprule_testing.create_outputs(
                ctx,
                "my_maprule",
                {
                    "OUT1": "out1",  # 3 conflicts
                    "OUT2": "{src_dir}/out2",  # 2 conflicts
                    "OUT3": "out3/{src_name}",  # 2 conflicts
                },
                strategy,
                foreach_srcs,
            )
        )

        for output in all_output_files:
            _dummy_generating_action(ctx, output)

        _assert_error_fragments(
            env,
            errors,
            ["out1", language + "/foo/src1.txt", "OUT1", language + "/foo/src2.pb.h", "OUT1"],
            msg = "assertion #1 (language: %s)" % language,
        )

        _assert_error_fragments(
            env,
            errors,
            ["out2", language + "/foo/src1.txt", "OUT2", language + "/foo/src2.pb.h", "OUT2"],
            msg = "assertion #2 (language: %s)" % language,
        )

        _assert_error_fragments(
            env,
            errors,
            ["out3/src1.txt", language + "/foo/src1.txt", "OUT3", language + "/bar/src1.txt", "OUT3"],
            msg = "assertion #5 (language: %s)" % language,
        )

    return unittest.end(env)

conflicting_outputs_test = unittest.make(_conflicting_outputs_test)

def maprule_test_suite():
    """Creates the test targets and test suite for maprule.bzl tests."""

    unittest.suite(
        "maprule_tests",
        src_placeholders_test,
        validate_attributes_test,
        as_path_test,
        is_relative_path_test,
        custom_envmap_test,
        conflicting_outputs_test,
    )