02b70be9c6
t.Parallel() makes defer weird. This commit moves the temporary dir setup
and teardown to the parallel subtest, so the teardown gets called after
the tests are finished.
More detailed explanation:
Consider this code:
```go
t.Run("group", func(t *testing.T) {
setUp()
t.Run("parallel test1", parallelTest1)
t.Run("parallel test2", parallelTest1)
t.Run("sequential test", sequentialTest)
cleanUp()
})
```
When the group subtest is started, firstly parallelTest1 is run. When
t.Parallel() in the parallelTest1 is hit, its execution is suspended and
parallelTest2 is started. Once again, t.Parallel() is hit and the
parallelTest2 is suspended. Now, sequentialTest is started. It doesn't
contain t.Parallel() so it's run without any interruptions. The group subtest
continues its execution and calls the cleanUp method. After the cleanup is
done, the group subtest returns and it's time for the important part:
The parallelTest1 and 2 are resumed and run in parallel. In other words,
the code after t.Parallel is run when the PARENT subtest returns.
The important (and weird) part is that the parent subtest of the parallel
subtests returns before its parallel children finish. However, just the inner
anonymous function returns. The containing t.Run("group", func(){...})
function does not return until all the parallel subtests are finished.
How to solve this? One solution is to move the cleanup out of the group
subtest:
```go
t.Run("group", func(t *testing.T) {
setUp()
t.Run("parallel test1", parallelTest1)
t.Run("parallel test2", parallelTest1)
t.Run("sequential test", sequentialTest)
})
cleanUp()
```
How does this work? The group subtest is not marked as parallel, so it just
runs from its beginning to its end (including the parallel subtests). After
it finishes, then the cleanUp is called.
In this commit I chose a different method: I just moved the clean up into each
parallel subtest. I think this is clearer than all that parallel magic I
tried explaining in previous paragraphs.
See the section "Run a group of tests in parallel":
https://blog.golang.org/subtests
and this paragraph:
https://golang.org/pkg/testing/#hdr-Subtests_and_Sub_benchmarks
90 lines
3.1 KiB
Go
90 lines
3.1 KiB
Go
// This package contains tests related to dnf-json and rpmmd package.
|
|
|
|
// +build integration
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/osbuild/osbuild-composer/internal/distro"
|
|
"github.com/osbuild/osbuild-composer/internal/distro/fedora30"
|
|
"github.com/osbuild/osbuild-composer/internal/distro/fedora31"
|
|
"github.com/osbuild/osbuild-composer/internal/distro/fedora32"
|
|
"github.com/osbuild/osbuild-composer/internal/rpmmd"
|
|
"github.com/osbuild/osbuild-composer/internal/test"
|
|
)
|
|
|
|
func TestFetchChecksum(t *testing.T) {
|
|
dir, err := test.SetUpTemporaryRepository()
|
|
defer func(dir string) {
|
|
err := test.TearDownTemporaryRepository(dir)
|
|
assert.Nil(t, err, "Failed to clean up temporary repository.")
|
|
}(dir)
|
|
assert.Nilf(t, err, "Failed to set up temporary repository: %v", err)
|
|
|
|
repoCfg := rpmmd.RepoConfig{
|
|
Id: "repo",
|
|
BaseURL: fmt.Sprintf("file://%s", dir),
|
|
IgnoreSSL: true,
|
|
}
|
|
rpmMetadata := rpmmd.NewRPMMD(path.Join(dir, "rpmmd"))
|
|
_, c, err := rpmMetadata.FetchMetadata([]rpmmd.RepoConfig{repoCfg}, "platform:f31", "x86_64")
|
|
assert.Nilf(t, err, "Failed to fetch checksum: %v", err)
|
|
assert.NotEqual(t, "", c["repo"], "The checksum is empty")
|
|
}
|
|
|
|
// This test loads all the repositories available in /repositories directory
|
|
// and tries to run depsolve for each architecture. With N architectures available
|
|
// this should run cross-arch dependency solving N-1 times.
|
|
func TestCrossArchDepsolve(t *testing.T) {
|
|
// Load repositories from the definition we provide in the RPM package
|
|
repoDir := "/usr/share/osbuild-composer"
|
|
|
|
// NOTE: we can add RHEL, but don't make it hard requirement because it will fail outside of VPN
|
|
for _, distroStruct := range []distro.Distro{fedora30.New(), fedora31.New(), fedora32.New()} {
|
|
t.Run(distroStruct.Name(), func(t *testing.T) {
|
|
|
|
// Run tests in parallel to speed up run times.
|
|
t.Parallel()
|
|
|
|
// Set up temporary directory for rpm/dnf cache
|
|
dir, err := ioutil.TempDir("/tmp", "rpmmd-test-")
|
|
require.Nilf(t, err, "Failed to create tmp dir for depsolve test: %v", err)
|
|
defer os.RemoveAll(dir)
|
|
rpm := rpmmd.NewRPMMD(dir)
|
|
|
|
repos, err := rpmmd.LoadRepositories([]string{repoDir}, distroStruct.Name())
|
|
require.NoErrorf(t, err, "Failed to LoadRepositories %v", distroStruct.Name())
|
|
|
|
for _, archStr := range distroStruct.ListArches() {
|
|
t.Run(archStr, func(t *testing.T) {
|
|
arch, err := distroStruct.GetArch(archStr)
|
|
require.NoError(t, err)
|
|
|
|
for _, imgTypeStr := range arch.ListImageTypes() {
|
|
t.Run(imgTypeStr, func(t *testing.T) {
|
|
imgType, err := arch.GetImageType(imgTypeStr)
|
|
require.NoError(t, err)
|
|
|
|
buildPackages := imgType.BuildPackages()
|
|
_, _, err = rpm.Depsolve(buildPackages, []string{}, repos[archStr], distroStruct.ModulePlatformID(), archStr)
|
|
assert.NoError(t, err)
|
|
|
|
basePackagesInclude, basePackagesExclude := imgType.BasePackages()
|
|
_, _, err = rpm.Depsolve(basePackagesInclude, basePackagesExclude, repos[archStr], distroStruct.ModulePlatformID(), archStr)
|
|
assert.NoError(t, err)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|