// 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.

package com.google.devtools.build.lib.rules.python;

import static com.google.common.truth.Truth.assertThat;
import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;

import com.google.common.collect.ImmutableMap;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.collect.nestedset.Order;
import com.google.devtools.build.lib.packages.StructImpl;
import com.google.devtools.build.lib.packages.StructProvider;
import com.google.devtools.build.lib.syntax.EvalException;
import com.google.devtools.build.lib.syntax.SkylarkNestedSet;
import com.google.devtools.build.lib.testutil.MoreAsserts.ThrowingRunnable;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Tests for {@link PyProvider}. */
@RunWith(JUnit4.class)
public class PyProviderTest extends BuildViewTestCase {

  /**
   * Constructs a py provider struct with the given field values and with default values for any
   * field not specified.
   *
   * <p>The struct is constructed directly, rather than using {@link PyProvider.Builder}, so that
   * the resulting instance is suitable for asserting on {@code PyProvider}'s operations over
   * structs with known contents. {@code overrides} is applied directly without validating the
   * fields' names or types.
   */
  private StructImpl makeStruct(Map<String, Object> overrides) {
    Map<String, Object> fields = new LinkedHashMap<>();
    fields.put(
        PyProvider.TRANSITIVE_SOURCES,
        SkylarkNestedSet.of(Artifact.class, NestedSetBuilder.emptySet(Order.COMPILE_ORDER)));
    fields.put(PyProvider.USES_SHARED_LIBRARIES, false);
    fields.put(
        PyProvider.IMPORTS,
        SkylarkNestedSet.of(String.class, NestedSetBuilder.emptySet(Order.COMPILE_ORDER)));
    fields.put(PyProvider.HAS_PY2_ONLY_SOURCES, false);
    fields.put(PyProvider.HAS_PY3_ONLY_SOURCES, false);
    fields.putAll(overrides);
    return StructProvider.STRUCT.create(fields, "No such attribute '%s'");
  }

  /** Defines //pytarget, a target that returns a py provider with some arbitrary field values. */
  private void definePyTarget() throws IOException {
    scratch.file("rules/BUILD");
    scratch.file(
        "rules/pyrule.bzl",
        "def _pyrule_impl(ctx):",
        "    info = struct(",
        "        transitive_sources = depset(direct=ctx.files.transitive_sources),",
        "        uses_shared_libraries = ctx.attr.uses_shared_libraries,",
        "        imports = depset(direct=ctx.attr.imports),",
        "        has_py2_only_sources = ctx.attr.has_py2_only_sources,",
        "        has_py3_only_sources = ctx.attr.has_py3_only_sources,",
        "    )",
        "    return struct(py=info)",
        "",
        "pyrule = rule(",
        "    implementation = _pyrule_impl,",
        "    attrs = {",
        "        'transitive_sources': attr.label_list(allow_files=True),",
        "        'uses_shared_libraries': attr.bool(default=False),",
        "        'imports': attr.string_list(),",
        "        'has_py2_only_sources': attr.bool(),",
        "        'has_py3_only_sources': attr.bool(),",
        "    },",
        ")");
    scratch.file(
        "pytarget/BUILD",
        "load('//rules:pyrule.bzl', 'pyrule')",
        "",
        "pyrule(",
        "    name = 'pytarget',",
        "    transitive_sources = ['a.py'],",
        "    uses_shared_libraries = True,",
        "    imports = ['b'],",
        "    has_py2_only_sources = True,",
        "    has_py3_only_sources = True,",
        ")");
    scratch.file("pytarget/a.py");
  }

  /** Defines //dummytarget, a target that returns no py provider. */
  private void defineDummyTarget() throws IOException {
    scratch.file("rules/BUILD");
    scratch.file(
        "rules/dummytarget.bzl",
        "def _dummyrule_impl(ctx):",
        "    pass",
        "",
        "dummyrule = rule(",
        "    implementation = _dummyrule_impl,",
        ")");
    scratch.file(
        "dummytarget/BUILD",
        "load('//rules:dummytarget.bzl', 'dummyrule')",
        "",
        "dummyrule(",
        "    name = 'dummytarget',",
        ")");
  }

  @Test
  public void hasProvider_True() throws Exception {
    definePyTarget();
    assertThat(PyProvider.hasProvider(getConfiguredTarget("//pytarget"))).isTrue();
  }

  @Test
  public void hasProvider_False() throws Exception {
    defineDummyTarget();
    assertThat(PyProvider.hasProvider(getConfiguredTarget("//dummytarget"))).isFalse();
  }

  @Test
  public void getProvider_Present() throws Exception {
    definePyTarget();
    StructImpl info = PyProvider.getProvider(getConfiguredTarget("//pytarget"));
    // If we got this far, it's present. getProvider() should never be null, but check just in case.
    assertThat(info).isNotNull();
  }

  @Test
  public void getProvider_Absent() throws Exception {
    defineDummyTarget();
    EvalException ex =
        assertThrows(
            EvalException.class,
            () -> PyProvider.getProvider(getConfiguredTarget("//dummytarget")));
    assertThat(ex).hasMessageThat().contains("Target does not have 'py' provider");
  }

  @Test
  public void getProvider_WrongType() throws Exception {
    // badtyperule() returns a "py" provider that has the wrong type.
    scratch.file("rules/BUILD");
    scratch.file(
        "rules/badtyperule.bzl",
        "def _badtyperule_impl(ctx):",
        "    return struct(py='abc')",
        "",
        "badtyperule = rule(",
        "    implementation = _badtyperule_impl",
        ")");
    scratch.file(
        "badtypetarget/BUILD",
        "load('//rules:badtyperule.bzl', 'badtyperule')",
        "",
        "badtyperule(",
        "    name = 'badtypetarget',",
        ")");
    EvalException ex =
        assertThrows(
            EvalException.class,
            () -> PyProvider.getProvider(getConfiguredTarget("//badtypetarget")));
    assertThat(ex).hasMessageThat().contains("'py' provider should be a struct");
  }

  private static void assertThrowsEvalExceptionContaining(
      ThrowingRunnable runnable, String message) {
    assertThat(assertThrows(EvalException.class, runnable)).hasMessageThat().contains(message);
  }

  private static void assertHasMissingFieldMessage(ThrowingRunnable access, String fieldName) {
    assertThrowsEvalExceptionContaining(
        access, String.format("\'py' provider missing '%s' field", fieldName));
  }

  private static void assertHasWrongTypeMessage(
      ThrowingRunnable access, String fieldName, String expectedType) {
    assertThrowsEvalExceptionContaining(
        access,
        String.format(
            "\'py' provider's '%s' field should be a %s (got a 'int')", fieldName, expectedType));
  }

  /** We need this because {@code NestedSet}s don't have value equality. */
  private static void assertHasOrderAndContainsExactly(
      NestedSet<?> set, Order order, Object... values) {
    assertThat(set.getOrder()).isEqualTo(order);
    assertThat(set).containsExactly(values);
  }

  @Test
  public void getTransitiveSources_Good() throws Exception {
    NestedSet<Artifact> sources =
        NestedSetBuilder.create(Order.COMPILE_ORDER, getSourceArtifact("dummy"));
    StructImpl info =
        makeStruct(
            ImmutableMap.of(
                PyProvider.TRANSITIVE_SOURCES, SkylarkNestedSet.of(Artifact.class, sources)));
    assertThat(PyProvider.getTransitiveSources(info)).isSameAs(sources);
  }

  @Test
  public void getTransitiveSources_Missing() {
    StructImpl info = StructProvider.STRUCT.createEmpty(null);
    assertHasMissingFieldMessage(() -> PyProvider.getTransitiveSources(info), "transitive_sources");
  }

  @Test
  public void getTransitiveSources_WrongType() {
    StructImpl info = makeStruct(ImmutableMap.of(PyProvider.TRANSITIVE_SOURCES, 123));
    assertHasWrongTypeMessage(
        () -> PyProvider.getTransitiveSources(info), "transitive_sources", "depset of Files");
  }

  @Test
  public void getTransitiveSources_OrderMismatch() throws Exception {
    reporter.removeHandler(failFastHandler);
    // Depset order mismatches should be caught as rule errors.
    scratch.file("rules/BUILD");
    scratch.file(
        "rules/badorderrule.bzl",
        "def _badorderrule_impl(ctx):",
        // Native rules use "compile" / "postorder", so using "preorder" here creates a conflict.
        "    info = struct(transitive_sources=depset(direct=[], order='preorder'))",
        "    return struct(py=info)",
        "",
        "badorderrule = rule(",
        "    implementation = _badorderrule_impl",
        ")");
    scratch.file(
        "badordertarget/BUILD",
        "load('//rules:badorderrule.bzl', 'badorderrule')",
        "",
        "badorderrule(",
        "    name = 'badorderdep',",
        ")",
        "py_library(",
        "    name = 'pylib',",
        "    srcs = ['pylib.py'],",
        ")",
        "py_binary(",
        "    name = 'pybin',",
        "    srcs = ['pybin.py'],",
        "    deps = [':pylib', ':badorderdep'],",
        ")");
    getConfiguredTarget("//badordertarget:pybin");
    assertContainsEvent(
        "Incompatible order for transitive_sources: expected 'default' or 'postorder', got "
            + "'preorder'");
  }

  @Test
  public void getUsesSharedLibraries_Good() throws Exception {
    StructImpl info = makeStruct(ImmutableMap.of(PyProvider.USES_SHARED_LIBRARIES, true));
    assertThat(PyProvider.getUsesSharedLibraries(info)).isTrue();
  }

  @Test
  public void getUsesSharedLibraries_Missing() throws Exception {
    StructImpl info = StructProvider.STRUCT.createEmpty(null);
    assertThat(PyProvider.getUsesSharedLibraries(info)).isFalse();
  }

  @Test
  public void getUsesSharedLibraries_WrongType() {
    StructImpl info = makeStruct(ImmutableMap.of(PyProvider.USES_SHARED_LIBRARIES, 123));
    assertHasWrongTypeMessage(
        () -> PyProvider.getUsesSharedLibraries(info), "uses_shared_libraries", "boolean");
  }

  @Test
  public void getImports_Good() throws Exception {
    NestedSet<String> imports = NestedSetBuilder.create(Order.COMPILE_ORDER, "abc");
    StructImpl info =
        makeStruct(ImmutableMap.of(PyProvider.IMPORTS, SkylarkNestedSet.of(String.class, imports)));
    assertThat(PyProvider.getImports(info)).isSameAs(imports);
  }

  @Test
  public void getImports_Missing() throws Exception {
    StructImpl info = StructProvider.STRUCT.createEmpty(null);
    assertHasOrderAndContainsExactly(PyProvider.getImports(info), Order.COMPILE_ORDER);
  }

  @Test
  public void getImports_WrongType() {
    StructImpl info = makeStruct(ImmutableMap.of(PyProvider.IMPORTS, 123));
    assertHasWrongTypeMessage(() -> PyProvider.getImports(info), "imports", "depset of strings");
  }

  @Test
  public void getHasPy2OnlySources_Good() throws Exception {
    StructImpl info = makeStruct(ImmutableMap.of(PyProvider.HAS_PY2_ONLY_SOURCES, true));
    assertThat(PyProvider.getHasPy2OnlySources(info)).isTrue();
  }

  @Test
  public void getHasPy2OnlySources_Missing() throws Exception {
    StructImpl info = StructProvider.STRUCT.createEmpty(null);
    assertThat(PyProvider.getHasPy2OnlySources(info)).isFalse();
  }

  @Test
  public void getHasPy2OnlySources_WrongType() {
    StructImpl info = makeStruct(ImmutableMap.of(PyProvider.HAS_PY2_ONLY_SOURCES, 123));
    assertHasWrongTypeMessage(
        () -> PyProvider.getHasPy2OnlySources(info), "has_py2_only_sources", "boolean");
  }

  @Test
  public void getHasPy3OnlySources_Good() throws Exception {
    StructImpl info = makeStruct(ImmutableMap.of(PyProvider.HAS_PY3_ONLY_SOURCES, true));
    assertThat(PyProvider.getHasPy3OnlySources(info)).isTrue();
  }

  @Test
  public void getHasPy3OnlySources_Missing() throws Exception {
    StructImpl info = StructProvider.STRUCT.createEmpty(null);
    assertThat(PyProvider.getHasPy3OnlySources(info)).isFalse();
  }

  @Test
  public void getHasPy3OnlySources_WrongType() {
    StructImpl info = makeStruct(ImmutableMap.of(PyProvider.HAS_PY3_ONLY_SOURCES, 123));
    assertHasWrongTypeMessage(
        () -> PyProvider.getHasPy3OnlySources(info), "has_py3_only_sources", "boolean");
  }

  /** Checks values set by the builder. */
  @Test
  public void builder() throws Exception {
    NestedSet<Artifact> sources =
        NestedSetBuilder.create(Order.COMPILE_ORDER, getSourceArtifact("dummy"));
    NestedSet<String> imports = NestedSetBuilder.create(Order.COMPILE_ORDER, "abc");
    StructImpl info =
        PyProvider.builder()
            .setTransitiveSources(sources)
            .setUsesSharedLibraries(true)
            .setImports(imports)
            .setHasPy2OnlySources(true)
            .setHasPy3OnlySources(true)
            .build();
    // Assert using struct operations, not PyProvider accessors, which aren't necessarily trusted to
    // be correct.
    assertHasOrderAndContainsExactly(
        ((SkylarkNestedSet) info.getValue(PyProvider.TRANSITIVE_SOURCES)).getSet(Artifact.class),
        Order.COMPILE_ORDER,
        getSourceArtifact("dummy"));
    assertThat((Boolean) info.getValue(PyProvider.USES_SHARED_LIBRARIES)).isTrue();
    assertHasOrderAndContainsExactly(
        ((SkylarkNestedSet) info.getValue(PyProvider.IMPORTS)).getSet(String.class),
        Order.COMPILE_ORDER,
        "abc");
    assertThat((Boolean) info.getValue(PyProvider.HAS_PY2_ONLY_SOURCES)).isTrue();
    assertThat((Boolean) info.getValue(PyProvider.HAS_PY3_ONLY_SOURCES)).isTrue();
  }

  /** Checks the defaults set by the builder. */
  @Test
  public void builderDefaults() throws Exception {
    // transitive_sources is mandatory, so create a dummy value but no need to assert on it.
    NestedSet<Artifact> sources =
        NestedSetBuilder.create(Order.COMPILE_ORDER, getSourceArtifact("dummy"));
    StructImpl info = PyProvider.builder().setTransitiveSources(sources).build();
    // Assert using struct operations, not PyProvider accessors, which aren't necessarily trusted to
    // be correct.
    assertThat((Boolean) info.getValue(PyProvider.USES_SHARED_LIBRARIES)).isFalse();
    assertHasOrderAndContainsExactly(
        ((SkylarkNestedSet) info.getValue(PyProvider.IMPORTS)).getSet(String.class),
        Order.COMPILE_ORDER);
    assertThat((Boolean) info.getValue(PyProvider.HAS_PY2_ONLY_SOURCES)).isFalse();
    assertThat((Boolean) info.getValue(PyProvider.HAS_PY3_ONLY_SOURCES)).isFalse();
  }
}