arno
/
clair
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

database: move dbutil and testutil to database from pkg

Browse Source 
Move dbutil and testutil to database from pkg
Rename all "result"
master
Sida Chen 6 years ago
parent 0c1b80b2ed
commit e657d26313
9 changed files with 90 additions and 89 deletions
Show Stats Download Patch File Download Diff File

70
pkg/dbutil/dbutil.go → database/dbutil.go
Unescape View File

@ -12,47 +12,45 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package dbutil
package database
import (
"github.com/deckarep/golang-set"
"github.com/coreos/clair/database"
)
// DeduplicateNamespaces deduplicates a list of namespaces.
func DeduplicateNamespaces(namespaces ...database.Namespace) []database.Namespace {
func DeduplicateNamespaces(namespaces ...Namespace) []Namespace {
nsSet := mapset.NewSet()
for _, ns := range namespaces {
nsSet.Add(ns)
}
result := make([]database.Namespace, 0, nsSet.Cardinality())
uniqueNamespaces := make([]Namespace, 0, nsSet.Cardinality())
for ns := range nsSet.Iter() {
result = append(result, ns.(database.Namespace))
uniqueNamespaces = append(uniqueNamespaces, ns.(Namespace))
}
return result
return uniqueNamespaces
}
// DeduplicateFeatures deduplicates a list of list of features.
func DeduplicateFeatures(features ...database.Feature) []database.Feature {
func DeduplicateFeatures(features ...Feature) []Feature {
fSet := mapset.NewSet()
for _, f := range features {
fSet.Add(f)
}
result := make([]database.Feature, 0, fSet.Cardinality())
uniqueFeatures := make([]Feature, 0, fSet.Cardinality())
for f := range fSet.Iter() {
result = append(result, f.(database.Feature))
uniqueFeatures = append(uniqueFeatures, f.(Feature))
}
return result
return uniqueFeatures
}
// PersistPartialLayer wraps session PersistLayer function with begin and
// commit.
func PersistPartialLayer(datastore database.Datastore, layer *database.Layer) error {
func PersistPartialLayer(datastore Datastore, layer *Layer) error {
tx, err := datastore.Begin()
if err != nil {
return err
@ -67,7 +65,7 @@ func PersistPartialLayer(datastore database.Datastore, layer *database.Layer) er
}
// PersistFeatures wraps session PersistFeatures function with begin and commit.
func PersistFeatures(datastore database.Datastore, features []database.Feature) error {
func PersistFeatures(datastore Datastore, features []Feature) error {
tx, err := datastore.Begin()
if err != nil {
return err
@ -82,7 +80,7 @@ func PersistFeatures(datastore database.Datastore, features []database.Feature)
// PersistNamespaces wraps session PersistNamespaces function with begin and
// commit.
func PersistNamespaces(datastore database.Datastore, namespaces []database.Namespace) error {
func PersistNamespaces(datastore Datastore, namespaces []Namespace) error {
tx, err := datastore.Begin()
if err != nil {
return err
@ -97,20 +95,20 @@ func PersistNamespaces(datastore database.Datastore, namespaces []database.Names
}
// FindAncestry wraps session FindAncestry function with begin and rollback.
func FindAncestry(datastore database.Datastore, name string) (database.Ancestry, bool, error) {
func FindAncestry(datastore Datastore, name string) (Ancestry, bool, error) {
tx, err := datastore.Begin()
defer tx.Rollback()
if err != nil {
return database.Ancestry{}, false, err
return Ancestry{}, false, err
}
return tx.FindAncestry(name)
}
// FindLayer wraps session FindLayer function with begin and rollback.
func FindLayer(datastore database.Datastore, hash string) (layer database.Layer, ok bool, err error) {
var tx database.Session
func FindLayer(datastore Datastore, hash string) (layer Layer, ok bool, err error) {
var tx Session
if tx, err = datastore.Begin(); err != nil {
return
}
@ -122,24 +120,24 @@ func FindLayer(datastore database.Datastore, hash string) (layer database.Layer,
// DeduplicateNamespacedFeatures returns a copy of all unique features in the
// input.
func DeduplicateNamespacedFeatures(features []database.NamespacedFeature) []database.NamespacedFeature {
func DeduplicateNamespacedFeatures(features []NamespacedFeature) []NamespacedFeature {
nsSet := mapset.NewSet()
for _, ns := range features {
nsSet.Add(ns)
}
result := make([]database.NamespacedFeature, 0, nsSet.Cardinality())
uniqueFeatures := make([]NamespacedFeature, 0, nsSet.Cardinality())
for ns := range nsSet.Iter() {
result = append(result, ns.(database.NamespacedFeature))
uniqueFeatures = append(uniqueFeatures, ns.(NamespacedFeature))
}
return result
return uniqueFeatures
}
// GetAncestryFeatures returns a list of unique namespaced features in the
// ancestry.
func GetAncestryFeatures(ancestry database.Ancestry) []database.NamespacedFeature {
features := []database.NamespacedFeature{}
func GetAncestryFeatures(ancestry Ancestry) []NamespacedFeature {
features := []NamespacedFeature{}
for _, layer := range ancestry.Layers {
features = append(features, layer.GetFeatures()...)
}
@ -148,7 +146,7 @@ func GetAncestryFeatures(ancestry database.Ancestry) []database.NamespacedFeatur
}
// UpsertAncestry wraps session UpsertAncestry function with begin and commit.
func UpsertAncestry(datastore database.Datastore, ancestry database.Ancestry) error {
func UpsertAncestry(datastore Datastore, ancestry Ancestry) error {
tx, err := datastore.Begin()
if err != nil {
return err
@ -168,7 +166,7 @@ func UpsertAncestry(datastore database.Datastore, ancestry database.Ancestry) er
// PersistNamespacedFeatures wraps session PersistNamespacedFeatures function
// with begin and commit.
func PersistNamespacedFeatures(datastore database.Datastore, features []database.NamespacedFeature) error {
func PersistNamespacedFeatures(datastore Datastore, features []NamespacedFeature) error {
tx, err := datastore.Begin()
if err != nil {
return err
@ -188,7 +186,7 @@ func PersistNamespacedFeatures(datastore database.Datastore, features []database
// CacheRelatedVulnerability wraps session CacheAffectedNamespacedFeatures
// function with begin and commit.
func CacheRelatedVulnerability(datastore database.Datastore, features []database.NamespacedFeature) error {
func CacheRelatedVulnerability(datastore Datastore, features []NamespacedFeature) error {
tx, err := datastore.Begin()
if err != nil {
return err
@ -203,7 +201,7 @@ func CacheRelatedVulnerability(datastore database.Datastore, features []database
}
// IntersectDetectors returns the detectors in both d1 and d2.
func IntersectDetectors(d1 []database.Detector, d2 []database.Detector) []database.Detector {
func IntersectDetectors(d1 []Detector, d2 []Detector) []Detector {
d1Set := mapset.NewSet()
for _, d := range d1 {
d1Set.Add(d)
@ -215,16 +213,16 @@ func IntersectDetectors(d1 []database.Detector, d2 []database.Detector) []databa
}
inter := d1Set.Intersect(d2Set)
result := make([]database.Detector, 0, inter.Cardinality())
detectors := make([]Detector, 0, inter.Cardinality())
for d := range inter.Iter() {
result = append(result, d.(database.Detector))
detectors = append(detectors, d.(Detector))
}
return result
return detectors
}
// DiffDetectors returns the detectors belongs to d1 but not d2
func DiffDetectors(d1 []database.Detector, d2 []database.Detector) []database.Detector {
func DiffDetectors(d1 []Detector, d2 []Detector) []Detector {
d1Set := mapset.NewSet()
for _, d := range d1 {
d1Set.Add(d)
@ -236,17 +234,17 @@ func DiffDetectors(d1 []database.Detector, d2 []database.Detector) []database.De
}
diff := d1Set.Difference(d2Set)
result := make([]database.Detector, 0, diff.Cardinality())
detectors := make([]Detector, 0, diff.Cardinality())
for d := range diff.Iter() {
result = append(result, d.(database.Detector))
detectors = append(detectors, d.(Detector))
}
return result
return detectors
}
// MergeLayers merges all content in new layer to l, where the content is
// updated.
func MergeLayers(l *database.Layer, new *database.Layer) *database.Layer {
func MergeLayers(l *Layer, new *Layer) *Layer {
featureSet := mapset.NewSet()
namespaceSet := mapset.NewSet()
bySet := mapset.NewSet()

5
database/pgsql/ancestry_test.go
Unescape View File

@ -20,7 +20,6 @@ import (
"github.com/stretchr/testify/assert"
"github.com/coreos/clair/database"
"github.com/coreos/clair/pkg/testutil"
)
var upsertAncestryTests = []struct {
@ -89,7 +88,7 @@ func TestUpsertAncestry(t *testing.T) {
actual, ok, err := tx.FindAncestry(test.in.Name)
assert.Nil(t, err)
assert.True(t, ok)
testutil.AssertAncestryEqual(t, test.in, &actual)
database.AssertAncestryEqual(t, test.in, &actual)
})
}
}
@ -132,7 +131,7 @@ func TestFindAncestry(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, test.ok, ok)
if test.ok {
testutil.AssertAncestryEqual(t, test.ancestry, &ancestry)
database.AssertAncestryEqual(t, test.ancestry, &ancestry)
}
})
}

5
database/pgsql/layer_test.go
Unescape View File

@ -20,7 +20,6 @@ import (
"github.com/stretchr/testify/assert"
"github.com/coreos/clair/database"
"github.com/coreos/clair/pkg/testutil"
)
var persistLayerTests = []struct {
@ -136,7 +135,7 @@ func TestPersistLayer(t *testing.T) {
layer, ok, err := tx.FindLayer(test.name)
assert.Nil(t, err)
assert.True(t, ok)
testutil.AssertLayerEqual(t, test.layer, &layer)
database.AssertLayerEqual(t, test.layer, &layer)
}
})
}
@ -184,7 +183,7 @@ func TestFindLayer(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, test.ok, ok)
if test.ok {
testutil.AssertLayerEqual(t, test.out, &layer)
database.AssertLayerEqual(t, test.out, &layer)
}
})
}

5
database/pgsql/testutil.go
Unescape View File

@ -21,7 +21,6 @@ import (
"github.com/coreos/clair/database"
"github.com/coreos/clair/pkg/pagination"
"github.com/coreos/clair/pkg/testutil"
)
// int keys must be the consistent with the database ID.
@ -232,12 +231,12 @@ func AssertPagedVulnerableAncestriesEqual(t *testing.T, key pagination.Key, expe
return assert.Equal(t, expected, actual)
}
return testutil.AssertVulnerabilityEqual(t, &expected.Vulnerability, &actual.Vulnerability) &&
return database.AssertVulnerabilityEqual(t, &expected.Vulnerability, &actual.Vulnerability) &&
assert.Equal(t, expected.Limit, actual.Limit) &&
assert.Equal(t, mustUnmarshalToken(key, expected.Current), mustUnmarshalToken(key, actual.Current)) &&
assert.Equal(t, mustUnmarshalToken(key, expected.Next), mustUnmarshalToken(key, actual.Next)) &&
assert.Equal(t, expected.End, actual.End) &&
testutil.AssertIntStringMapEqual(t, expected.Affected, actual.Affected)
database.AssertIntStringMapEqual(t, expected.Affected, actual.Affected)
}
func mustUnmarshalToken(key pagination.Key, token pagination.Token) Page {

44
pkg/testutil/testutil.go → database/testutil.go
Unescape View File

@ -1,4 +1,18 @@
package testutil
// Copyright 2018 clair authors
//
// 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 database
import (
"encoding/json"
@ -7,13 +21,11 @@ import (
"github.com/deckarep/golang-set"
"github.com/stretchr/testify/assert"
"github.com/coreos/clair/database"
)
// AssertDetectorsEqual asserts actual detectors are content wise equal to
// expected detectors regardless of the ordering.
func AssertDetectorsEqual(t *testing.T, expected, actual []database.Detector) bool {
func AssertDetectorsEqual(t *testing.T, expected, actual []Detector) bool {
if len(expected) != len(actual) {
return assert.Fail(t, "detectors are not equal", "expected: '%v', actual: '%v'", expected, actual)
}
@ -37,7 +49,7 @@ func AssertDetectorsEqual(t *testing.T, expected, actual []database.Detector) bo
// AssertAncestryEqual asserts actual ancestry equals to expected ancestry
// content wise.
func AssertAncestryEqual(t *testing.T, expected, actual *database.Ancestry) bool {
func AssertAncestryEqual(t *testing.T, expected, actual *Ancestry) bool {
if expected == actual {
return true
}
@ -63,7 +75,7 @@ func AssertAncestryEqual(t *testing.T, expected, actual *database.Ancestry) bool
// AssertAncestryLayerEqual asserts actual ancestry layer equals to expected
// ancestry layer content wise.
func AssertAncestryLayerEqual(t *testing.T, expected, actual *database.AncestryLayer) bool {
func AssertAncestryLayerEqual(t *testing.T, expected, actual *AncestryLayer) bool {
if !assert.Equal(t, expected.Hash, actual.Hash) {
return false
}
@ -76,7 +88,7 @@ func AssertAncestryLayerEqual(t *testing.T, expected, actual *database.AncestryL
}
// feature -> is in actual layer
hitCounter := map[database.AncestryFeature]bool{}
hitCounter := map[AncestryFeature]bool{}
for _, f := range expected.Features {
hitCounter[f] = false
}
@ -131,9 +143,9 @@ func AssertElementsEqual(t *testing.T, expected, actual []interface{}) bool {
// AssertFeaturesEqual asserts content in actual equals content in expected
// regardless of ordering.
func AssertFeaturesEqual(t *testing.T, expected, actual []database.Feature) bool {
func AssertFeaturesEqual(t *testing.T, expected, actual []Feature) bool {
if assert.Len(t, actual, len(expected)) {
has := map[database.Feature]bool{}
has := map[Feature]bool{}
for _, nf := range expected {
has[nf] = false
}
@ -154,7 +166,7 @@ func AssertFeaturesEqual(t *testing.T, expected, actual []database.Feature) bool
// AssertLayerFeaturesEqual asserts content in actual equals to content in
// expected regardless of ordering.
func AssertLayerFeaturesEqual(t *testing.T, expected, actual []database.LayerFeature) bool {
func AssertLayerFeaturesEqual(t *testing.T, expected, actual []LayerFeature) bool {
if !assert.Len(t, actual, len(expected)) {
return false
}
@ -174,7 +186,7 @@ func AssertLayerFeaturesEqual(t *testing.T, expected, actual []database.LayerFea
// AssertNamespacesEqual asserts content in actual equals to content in
// expected regardless of ordering.
func AssertNamespacesEqual(t *testing.T, expected, actual []database.Namespace) bool {
func AssertNamespacesEqual(t *testing.T, expected, actual []Namespace) bool {
expectedInterfaces := []interface{}{}
for _, e := range expected {
expectedInterfaces = append(expectedInterfaces, e)
@ -190,7 +202,7 @@ func AssertNamespacesEqual(t *testing.T, expected, actual []database.Namespace)
// AssertLayerNamespacesEqual asserts content in actual equals to content in
// expected regardless of ordering.
func AssertLayerNamespacesEqual(t *testing.T, expected, actual []database.LayerNamespace) bool {
func AssertLayerNamespacesEqual(t *testing.T, expected, actual []LayerNamespace) bool {
expectedInterfaces := []interface{}{}
for _, e := range expected {
expectedInterfaces = append(expectedInterfaces, e)
@ -205,7 +217,7 @@ func AssertLayerNamespacesEqual(t *testing.T, expected, actual []database.LayerN
}
// AssertLayerEqual asserts actual layer equals to expected layer content wise.
func AssertLayerEqual(t *testing.T, expected, actual *database.Layer) bool {
func AssertLayerEqual(t *testing.T, expected, actual *Layer) bool {
if expected == actual {
return true
}
@ -239,7 +251,7 @@ func AssertIntStringMapEqual(t *testing.T, expected, actual map[int]string) bool
}
// AssertVulnerabilityEqual asserts two vulnerabilities are equal.
func AssertVulnerabilityEqual(t *testing.T, expected, actual *database.Vulnerability) bool {
func AssertVulnerabilityEqual(t *testing.T, expected, actual *Vulnerability) bool {
return assert.Equal(t, expected.Name, actual.Name) &&
assert.Equal(t, expected.Link, actual.Link) &&
assert.Equal(t, expected.Description, actual.Description) &&
@ -248,7 +260,7 @@ func AssertVulnerabilityEqual(t *testing.T, expected, actual *database.Vulnerabi
AssertMetadataMapEqual(t, expected.Metadata, actual.Metadata)
}
func castMetadataMapToInterface(metadata database.MetadataMap) map[string]interface{} {
func castMetadataMapToInterface(metadata MetadataMap) map[string]interface{} {
content, err := json.Marshal(metadata)
if err != nil {
panic(err)
@ -263,7 +275,7 @@ func castMetadataMapToInterface(metadata database.MetadataMap) map[string]interf
}
// AssertMetadataMapEqual asserts two metadata maps are equal.
func AssertMetadataMapEqual(t *testing.T, expected, actual database.MetadataMap) bool {
func AssertMetadataMapEqual(t *testing.T, expected, actual MetadataMap) bool {
expectedMap := castMetadataMapToInterface(expected)
actualMap := castMetadataMapToInterface(actual)
checked := mapset.NewSet()

3
ext/featurens/driver_test.go
Unescape View File

@ -8,7 +8,6 @@ import (
"github.com/coreos/clair/database"
"github.com/coreos/clair/ext/featurens"
"github.com/coreos/clair/pkg/tarutil"
"github.com/coreos/clair/pkg/testutil"
_ "github.com/coreos/clair/ext/featurens/alpinerelease"
_ "github.com/coreos/clair/ext/featurens/aptsources"
@ -50,6 +49,6 @@ func TestNamespaceDetector(t *testing.T) {
return
}
testutil.AssertLayerNamespacesEqual(t, test.out, out)
database.AssertLayerNamespacesEqual(t, test.out, out)
}
}

4
updater.go
Unescape View File

@ -21,8 +21,6 @@ import (
"sync"
"time"
"github.com/coreos/clair/pkg/dbutil"
"github.com/pborman/uuid"
"github.com/prometheus/client_golang/prometheus"
log "github.com/sirupsen/logrus"
@ -210,7 +208,7 @@ func update(datastore database.Datastore, firstUpdate bool) {
namespaces = append(namespaces, ns)
}
if err := dbutil.PersistNamespaces(datastore, namespaces); err != nil {
if err := database.PersistNamespaces(datastore, namespaces); err != nil {
log.WithError(err).Error("Unable to insert namespaces")
return
}

29
worker.go
Unescape View File

@ -26,7 +26,6 @@ import (
"github.com/coreos/clair/ext/featurens"
"github.com/coreos/clair/ext/imagefmt"
"github.com/coreos/clair/pkg/commonerr"
"github.com/coreos/clair/pkg/dbutil"
"github.com/coreos/clair/pkg/strutil"
"github.com/coreos/clair/pkg/tarutil"
)
@ -102,7 +101,7 @@ func processRequests(imageFormat string, toDetect map[string]*processRequest) (m
}
func getProcessRequest(datastore database.Datastore, req LayerRequest) (preq *processRequest, err error) {
layer, ok, err := dbutil.FindLayer(datastore, req.Hash)
layer, ok, err := database.FindLayer(datastore, req.Hash)
if err != nil {
return
}
@ -125,7 +124,7 @@ func getProcessRequest(datastore database.Datastore, req LayerRequest) (preq *pr
preq = &processRequest{
LayerRequest: req,
existingLayer: &layer,
detectors: dbutil.DiffDetectors(EnabledDetectors, layer.By),
detectors: database.DiffDetectors(EnabledDetectors, layer.By),
}
}
@ -140,18 +139,18 @@ func persistProcessResult(datastore database.Datastore, results map[string]*proc
namespaces = append(namespaces, r.newLayerContent.GetNamespaces()...)
}
features = dbutil.DeduplicateFeatures(features...)
namespaces = dbutil.DeduplicateNamespaces(namespaces...)
if err := dbutil.PersistNamespaces(datastore, namespaces); err != nil {
features = database.DeduplicateFeatures(features...)
namespaces = database.DeduplicateNamespaces(namespaces...)
if err := database.PersistNamespaces(datastore, namespaces); err != nil {
return err
}
if err := dbutil.PersistFeatures(datastore, features); err != nil {
if err := database.PersistFeatures(datastore, features); err != nil {
return err
}
for _, layer := range results {
if err := dbutil.PersistPartialLayer(datastore, layer.newLayerContent); err != nil {
if err := database.PersistPartialLayer(datastore, layer.newLayerContent); err != nil {
return err
}
}
@ -196,19 +195,19 @@ func processLayers(datastore database.Datastore, imageFormat string, requests []
func getProcessResultLayers(results map[string]*processResult) map[string]database.Layer {
layers := map[string]database.Layer{}
for name, r := range results {
layers[name] = *dbutil.MergeLayers(r.existingLayer, r.newLayerContent)
layers[name] = *database.MergeLayers(r.existingLayer, r.newLayerContent)
}
return layers
}
func isAncestryProcessed(datastore database.Datastore, name string) (bool, error) {
ancestry, ok, err := dbutil.FindAncestry(datastore, name)
ancestry, ok, err := database.FindAncestry(datastore, name)
if err != nil || !ok {
return ok, err
}
return len(dbutil.DiffDetectors(EnabledDetectors, ancestry.By)) == 0, nil
return len(database.DiffDetectors(EnabledDetectors, ancestry.By)) == 0, nil
}
// ProcessAncestry downloads and scans an ancestry if it's not scanned by all
@ -255,7 +254,7 @@ func processAncestry(datastore database.Datastore, name string, layers []databas
return err
}
ancestryFeatures := dbutil.GetAncestryFeatures(ancestry)
ancestryFeatures := database.GetAncestryFeatures(ancestry)
log.WithFields(log.Fields{
"ancestry": name,
"processed by": EnabledDetectors,
@ -263,17 +262,17 @@ func processAncestry(datastore database.Datastore, name string, layers []databas
"layer count": len(ancestry.Layers),
}).Debug("compute ancestry features")
if err := dbutil.PersistNamespacedFeatures(datastore, ancestryFeatures); err != nil {
if err := database.PersistNamespacedFeatures(datastore, ancestryFeatures); err != nil {
log.WithField("ancestry", name).WithError(err).Error("could not persist namespaced features for ancestry")
return err
}
if err := dbutil.CacheRelatedVulnerability(datastore, ancestryFeatures); err != nil {
if err := database.CacheRelatedVulnerability(datastore, ancestryFeatures); err != nil {
log.WithField("ancestry", name).WithError(err).Error("failed to cache feature related vulnerability")
return err
}
if err := dbutil.UpsertAncestry(datastore, ancestry); err != nil {
if err := database.UpsertAncestry(datastore, ancestry); err != nil {
log.WithField("ancestry", name).WithError(err).Error("could not upsert ancestry")
return err
}

14
worker_test.go
Unescape View File

@ -28,8 +28,6 @@ import (
"github.com/coreos/clair/ext/featurefmt"
"github.com/coreos/clair/ext/featurens"
"github.com/coreos/clair/ext/versionfmt/dpkg"
"github.com/coreos/clair/pkg/dbutil"
"github.com/coreos/clair/pkg/testutil"
// Register the required detectors.
_ "github.com/coreos/clair/ext/featurefmt/dpkg"
@ -203,7 +201,7 @@ func newMockDatastore() *mockDatastore {
}
layer, _ := session.copy.layers[hash]
dbutil.MergeLayers(&layer, &database.Layer{
database.MergeLayers(&layer, &database.Layer{
Hash: hash,
By: by,
Namespaces: namespaces,
@ -359,7 +357,7 @@ func TestProcessLayers(t *testing.T) {
// Ensure each layer has expected namespaces and features detected
if blank, ok := datastore.layers["blank"]; ok {
testutil.AssertDetectorsEqual(t, EnabledDetectors, blank.By)
database.AssertDetectorsEqual(t, EnabledDetectors, blank.By)
assert.Len(t, blank.Namespaces, 0)
assert.Len(t, blank.Features, 0)
} else {
@ -368,7 +366,7 @@ func TestProcessLayers(t *testing.T) {
}
if wheezy, ok := datastore.layers["wheezy"]; ok {
testutil.AssertDetectorsEqual(t, EnabledDetectors, wheezy.By)
database.AssertDetectorsEqual(t, EnabledDetectors, wheezy.By)
assert.Equal(t, []database.LayerNamespace{
{database.Namespace{"debian:7", dpkg.ParserName}, database.NewNamespaceDetector("os-release", "1.0")},
}, wheezy.Namespaces)
@ -380,7 +378,7 @@ func TestProcessLayers(t *testing.T) {
}
if jessie, ok := datastore.layers["jessie"]; ok {
testutil.AssertDetectorsEqual(t, EnabledDetectors, jessie.By)
database.AssertDetectorsEqual(t, EnabledDetectors, jessie.By)
assert.Equal(t, []database.LayerNamespace{
{database.Namespace{"debian:8", dpkg.ParserName}, database.NewNamespaceDetector("os-release", "1.0")},
}, jessie.Namespaces)
@ -578,8 +576,8 @@ func TestComputeAncestryFeatures(t *testing.T) {
ancestryLayers, detectors, err := computeAncestryLayers(layers)
require.Nil(t, err)
testutil.AssertDetectorsEqual(t, expectedDetectors, detectors)
database.AssertDetectorsEqual(t, expectedDetectors, detectors)
for i := range expected {
testutil.AssertAncestryLayerEqual(t, &expected[i], &ancestryLayers[i])
database.AssertAncestryLayerEqual(t, &expected[i], &ancestryLayers[i])
}
}

Write Preview
Loading…
Cancel
Save