5985846f29
Context: yaqs/7447701439926763520#a1 Bug: b/339454115 Test: go test Change-Id: If3ed81334a192993d32404301b55ca7b4f5780ae
456 lines
11 KiB
Go
456 lines
11 KiB
Go
// Copyright 2017 Google Inc. 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 python
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"android/soong/android"
|
|
"android/soong/cc"
|
|
|
|
"github.com/google/blueprint"
|
|
)
|
|
|
|
type pyModule struct {
|
|
name string
|
|
actualVersion string
|
|
pyRunfiles []string
|
|
srcsZip string
|
|
depsSrcsZips []string
|
|
}
|
|
|
|
var (
|
|
buildNamePrefix = "soong_python_test"
|
|
// We allow maching almost anything before the actual variant so that the os/arch variant
|
|
// is matched.
|
|
moduleVariantErrTemplate = `%s: module %q variant "[a-zA-Z0-9_]*%s": `
|
|
pkgPathErrTemplate = moduleVariantErrTemplate +
|
|
"pkg_path: %q must be a relative path contained in par file."
|
|
badIdentifierErrTemplate = moduleVariantErrTemplate +
|
|
"srcs: the path %q contains invalid subpath %q."
|
|
dupRunfileErrTemplate = moduleVariantErrTemplate +
|
|
"found two files to be placed at the same location within zip %q." +
|
|
" First file: in module %s at path %q." +
|
|
" Second file: in module %s at path %q."
|
|
noSrcFileErr = moduleVariantErrTemplate + "doesn't have any source files!"
|
|
badSrcFileExtErr = moduleVariantErrTemplate + "srcs: found non (.py|.proto) file: %q!"
|
|
badDataFileExtErr = moduleVariantErrTemplate + "data: found (.py) file: %q!"
|
|
bpFile = "Android.bp"
|
|
|
|
data = []struct {
|
|
desc string
|
|
mockFiles android.MockFS
|
|
|
|
errors []string
|
|
expectedBinaries []pyModule
|
|
}{
|
|
{
|
|
desc: "module without any src files",
|
|
mockFiles: map[string][]byte{
|
|
filepath.Join("dir", bpFile): []byte(
|
|
`python_library_host {
|
|
name: "lib1",
|
|
}`,
|
|
),
|
|
},
|
|
errors: []string{
|
|
fmt.Sprintf(noSrcFileErr,
|
|
"dir/Android.bp:1:1", "lib1", "PY3"),
|
|
},
|
|
},
|
|
{
|
|
desc: "module with bad src file ext",
|
|
mockFiles: map[string][]byte{
|
|
filepath.Join("dir", bpFile): []byte(
|
|
`python_library_host {
|
|
name: "lib1",
|
|
srcs: [
|
|
"file1.exe",
|
|
],
|
|
}`,
|
|
),
|
|
"dir/file1.exe": nil,
|
|
},
|
|
errors: []string{
|
|
fmt.Sprintf(badSrcFileExtErr,
|
|
"dir/Android.bp:3:11", "lib1", "PY3", "dir/file1.exe"),
|
|
},
|
|
},
|
|
{
|
|
desc: "module with bad data file ext",
|
|
mockFiles: map[string][]byte{
|
|
filepath.Join("dir", bpFile): []byte(
|
|
`python_library_host {
|
|
name: "lib1",
|
|
srcs: [
|
|
"file1.py",
|
|
],
|
|
data: [
|
|
"file2.py",
|
|
],
|
|
}`,
|
|
),
|
|
"dir/file1.py": nil,
|
|
"dir/file2.py": nil,
|
|
},
|
|
errors: []string{
|
|
fmt.Sprintf(badDataFileExtErr,
|
|
"dir/Android.bp:6:11", "lib1", "PY3", "dir/file2.py"),
|
|
},
|
|
},
|
|
{
|
|
desc: "module with bad pkg_path format",
|
|
mockFiles: map[string][]byte{
|
|
filepath.Join("dir", bpFile): []byte(
|
|
`python_library_host {
|
|
name: "lib1",
|
|
pkg_path: "a/c/../../",
|
|
srcs: [
|
|
"file1.py",
|
|
],
|
|
}
|
|
|
|
python_library_host {
|
|
name: "lib2",
|
|
pkg_path: "a/c/../../../",
|
|
srcs: [
|
|
"file1.py",
|
|
],
|
|
}
|
|
|
|
python_library_host {
|
|
name: "lib3",
|
|
pkg_path: "/a/c/../../",
|
|
srcs: [
|
|
"file1.py",
|
|
],
|
|
}`,
|
|
),
|
|
"dir/file1.py": nil,
|
|
},
|
|
errors: []string{
|
|
fmt.Sprintf(pkgPathErrTemplate,
|
|
"dir/Android.bp:11:15", "lib2", "PY3", "a/c/../../../"),
|
|
fmt.Sprintf(pkgPathErrTemplate,
|
|
"dir/Android.bp:19:15", "lib3", "PY3", "/a/c/../../"),
|
|
},
|
|
},
|
|
{
|
|
desc: "module with bad runfile src path format",
|
|
mockFiles: map[string][]byte{
|
|
filepath.Join("dir", bpFile): []byte(
|
|
`python_library_host {
|
|
name: "lib1",
|
|
pkg_path: "a/b/c/",
|
|
srcs: [
|
|
".file1.py",
|
|
"123/file1.py",
|
|
"-e/f/file1.py",
|
|
],
|
|
}`,
|
|
),
|
|
"dir/.file1.py": nil,
|
|
"dir/123/file1.py": nil,
|
|
"dir/-e/f/file1.py": nil,
|
|
},
|
|
errors: []string{
|
|
fmt.Sprintf(badIdentifierErrTemplate, "dir/Android.bp:4:11",
|
|
"lib1", "PY3", "a/b/c/-e/f/file1.py", "-e"),
|
|
fmt.Sprintf(badIdentifierErrTemplate, "dir/Android.bp:4:11",
|
|
"lib1", "PY3", "a/b/c/.file1.py", ".file1"),
|
|
fmt.Sprintf(badIdentifierErrTemplate, "dir/Android.bp:4:11",
|
|
"lib1", "PY3", "a/b/c/123/file1.py", "123"),
|
|
},
|
|
},
|
|
{
|
|
desc: "module with duplicate runfile path",
|
|
mockFiles: map[string][]byte{
|
|
filepath.Join("dir", bpFile): []byte(
|
|
`python_library_host {
|
|
name: "lib1",
|
|
pkg_path: "a/b/",
|
|
srcs: [
|
|
"c/file1.py",
|
|
],
|
|
}
|
|
|
|
python_library_host {
|
|
name: "lib2",
|
|
pkg_path: "a/b/c/",
|
|
srcs: [
|
|
"file1.py",
|
|
],
|
|
libs: [
|
|
"lib1",
|
|
],
|
|
}
|
|
|
|
python_binary_host {
|
|
name: "bin",
|
|
pkg_path: "e/",
|
|
srcs: [
|
|
"bin.py",
|
|
],
|
|
libs: [
|
|
"lib2",
|
|
],
|
|
}
|
|
`,
|
|
),
|
|
"dir/c/file1.py": nil,
|
|
"dir/file1.py": nil,
|
|
"dir/bin.py": nil,
|
|
},
|
|
errors: []string{
|
|
fmt.Sprintf(dupRunfileErrTemplate, "dir/Android.bp:20:6",
|
|
"bin", "PY3", "a/b/c/file1.py", "bin", "dir/file1.py",
|
|
"lib1", "dir/c/file1.py"),
|
|
},
|
|
},
|
|
{
|
|
desc: "module for testing dependencies",
|
|
mockFiles: map[string][]byte{
|
|
filepath.Join("dir", bpFile): []byte(
|
|
`python_defaults {
|
|
name: "default_lib",
|
|
srcs: [
|
|
"default.py",
|
|
],
|
|
version: {
|
|
py2: {
|
|
enabled: true,
|
|
srcs: [
|
|
"default_py2.py",
|
|
],
|
|
},
|
|
py3: {
|
|
enabled: false,
|
|
srcs: [
|
|
"default_py3.py",
|
|
],
|
|
},
|
|
},
|
|
}
|
|
|
|
python_library_host {
|
|
name: "lib5",
|
|
pkg_path: "a/b/",
|
|
srcs: [
|
|
"file1.py",
|
|
],
|
|
version: {
|
|
py2: {
|
|
enabled: true,
|
|
},
|
|
py3: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
|
|
python_library_host {
|
|
name: "lib6",
|
|
pkg_path: "c/d/",
|
|
srcs: [
|
|
"file2.py",
|
|
],
|
|
libs: [
|
|
"lib5",
|
|
],
|
|
}
|
|
|
|
python_binary_host {
|
|
name: "bin",
|
|
defaults: ["default_lib"],
|
|
pkg_path: "e/",
|
|
srcs: [
|
|
"bin.py",
|
|
],
|
|
libs: [
|
|
"lib5",
|
|
],
|
|
version: {
|
|
py3: {
|
|
enabled: true,
|
|
srcs: [
|
|
"file4.py",
|
|
],
|
|
libs: [
|
|
"lib6",
|
|
],
|
|
},
|
|
},
|
|
}`,
|
|
),
|
|
filepath.Join("dir", "default.py"): nil,
|
|
filepath.Join("dir", "default_py2.py"): nil,
|
|
filepath.Join("dir", "default_py3.py"): nil,
|
|
filepath.Join("dir", "file1.py"): nil,
|
|
filepath.Join("dir", "file2.py"): nil,
|
|
filepath.Join("dir", "bin.py"): nil,
|
|
filepath.Join("dir", "file4.py"): nil,
|
|
},
|
|
expectedBinaries: []pyModule{
|
|
{
|
|
name: "bin",
|
|
actualVersion: "PY3",
|
|
pyRunfiles: []string{
|
|
"e/default.py",
|
|
"e/bin.py",
|
|
"e/default_py3.py",
|
|
"e/file4.py",
|
|
},
|
|
srcsZip: "out/soong/.intermediates/dir/bin/PY3/bin.py.srcszip",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
)
|
|
|
|
func TestPythonModule(t *testing.T) {
|
|
for _, d := range data {
|
|
if d.desc != "module with duplicate runfile path" {
|
|
continue
|
|
}
|
|
d.mockFiles[filepath.Join("common", bpFile)] = []byte(`
|
|
python_library {
|
|
name: "py3-stdlib",
|
|
host_supported: true,
|
|
}
|
|
cc_binary {
|
|
name: "py3-launcher",
|
|
host_supported: true,
|
|
}
|
|
`)
|
|
|
|
t.Run(d.desc, func(t *testing.T) {
|
|
result := android.GroupFixturePreparers(
|
|
android.PrepareForTestWithDefaults,
|
|
android.PrepareForTestWithArchMutator,
|
|
android.PrepareForTestWithAllowMissingDependencies,
|
|
cc.PrepareForTestWithCcDefaultModules,
|
|
PrepareForTestWithPythonBuildComponents,
|
|
d.mockFiles.AddToFixture(),
|
|
).ExtendWithErrorHandler(android.FixtureExpectsAllErrorsToMatchAPattern(d.errors)).
|
|
RunTest(t)
|
|
|
|
if len(result.Errs) > 0 {
|
|
return
|
|
}
|
|
|
|
for _, e := range d.expectedBinaries {
|
|
t.Run(e.name, func(t *testing.T) {
|
|
expectModule(t, result.TestContext, e.name, e.actualVersion, e.srcsZip, e.pyRunfiles)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTestOnlyProvider(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := android.GroupFixturePreparers(
|
|
PrepareForTestWithPythonBuildComponents,
|
|
android.PrepareForTestWithAllowMissingDependencies,
|
|
).RunTestWithBp(t, `
|
|
// These should be test-only
|
|
python_library { name: "py-lib-test", test_only: true }
|
|
python_library { name: "py-lib-test-host", test_only: true, host_supported: true }
|
|
python_test { name: "py-test", srcs: ["py-test.py"] }
|
|
python_test_host { name: "py-test-host", srcs: ["py-test-host.py"] }
|
|
python_binary_host { name: "py-bin-test", srcs: ["py-bin-test.py"] }
|
|
|
|
// These should not be.
|
|
python_library { name: "py-lib" }
|
|
python_binary_host { name: "py-bin", srcs: ["py-bin.py"] }
|
|
`)
|
|
|
|
// Visit all modules and ensure only the ones that should
|
|
// marked as test-only are marked as test-only.
|
|
|
|
actualTestOnly := []string{}
|
|
ctx.VisitAllModules(func(m blueprint.Module) {
|
|
if provider, ok := android.OtherModuleProvider(ctx.TestContext.OtherModuleProviderAdaptor(), m, android.TestOnlyProviderKey); ok {
|
|
if provider.TestOnly {
|
|
actualTestOnly = append(actualTestOnly, m.Name())
|
|
}
|
|
}
|
|
})
|
|
expectedTestOnlyModules := []string{
|
|
"py-lib-test",
|
|
"py-lib-test-host",
|
|
"py-test",
|
|
"py-test-host",
|
|
}
|
|
|
|
notEqual, left, right := android.ListSetDifference(expectedTestOnlyModules, actualTestOnly)
|
|
if notEqual {
|
|
t.Errorf("test-only: Expected but not found: %v, Found but not expected: %v", left, right)
|
|
}
|
|
}
|
|
|
|
// Don't allow setting test-only on things that are always tests or never tests.
|
|
func TestInvalidTestOnlyTargets(t *testing.T) {
|
|
testCases := []string{
|
|
` python_test { name: "py-test", test_only: true, srcs: ["py-test.py"] } `,
|
|
` python_test_host { name: "py-test-host", test_only: true, srcs: ["py-test-host.py"] } `,
|
|
` python_defaults { name: "py-defaults", test_only: true, srcs: ["foo.py"] } `,
|
|
}
|
|
|
|
for i, bp := range testCases {
|
|
ctx := android.GroupFixturePreparers(
|
|
PrepareForTestWithPythonBuildComponents,
|
|
android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
|
|
|
|
ctx.RegisterModuleType("python_defaults", DefaultsFactory)
|
|
}),
|
|
android.PrepareForTestWithAllowMissingDependencies).
|
|
ExtendWithErrorHandler(android.FixtureIgnoreErrors).
|
|
RunTestWithBp(t, bp)
|
|
if len(ctx.Errs) != 1 {
|
|
t.Errorf("Expected err setting test_only in testcase #%d: %d errs", i, len(ctx.Errs))
|
|
continue
|
|
}
|
|
if !strings.Contains(ctx.Errs[0].Error(), "unrecognized property \"test_only\"") {
|
|
t.Errorf("ERR: %s bad bp: %s", ctx.Errs[0], bp)
|
|
}
|
|
}
|
|
}
|
|
|
|
func expectModule(t *testing.T, ctx *android.TestContext, name, variant, expectedSrcsZip string, expectedPyRunfiles []string) {
|
|
module := ctx.ModuleForTests(name, variant)
|
|
|
|
base, baseOk := module.Module().(*PythonLibraryModule)
|
|
if !baseOk {
|
|
t.Fatalf("%s is not Python module!", name)
|
|
}
|
|
|
|
actualPyRunfiles := []string{}
|
|
for _, path := range base.srcsPathMappings {
|
|
actualPyRunfiles = append(actualPyRunfiles, path.dest)
|
|
}
|
|
|
|
android.AssertDeepEquals(t, "pyRunfiles", expectedPyRunfiles, actualPyRunfiles)
|
|
|
|
android.AssertPathRelativeToTopEquals(t, "srcsZip", expectedSrcsZip, base.srcsZip)
|
|
}
|
|
|
|
func TestMain(m *testing.M) {
|
|
os.Exit(m.Run())
|
|
}
|