Golang types.NewVersionUnsafe函数代码示例

func TestInsertVulnerabilityNotifications(t *testing.T) {
	Open(&config.DatabaseConfig{Type: "memstore"})
	defer Close()

	pkg1 := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")}
	pkg1b := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.2")}
	pkg2 := &Package{OS: "testOS", Name: "testpkg2", Version: types.NewVersionUnsafe("1.0")}
	InsertPackages([]*Package{pkg1, pkg1b, pkg2})

	// NewVulnerabilityNotification
	vuln1 := &Vulnerability{ID: "test1", Link: "link1", Priority: types.Medium, Description: "testDescription1", FixedInNodes: []string{pkg1.Node}}
	vuln2 := &Vulnerability{ID: "test2", Link: "link2", Priority: types.High, Description: "testDescription2", FixedInNodes: []string{pkg1.Node, pkg2.Node}}
	vuln1b := &Vulnerability{ID: "test1", Priority: types.High, FixedInNodes: []string{"pkg3"}}
	notifications, err := InsertVulnerabilities([]*Vulnerability{vuln1, vuln2, vuln1b})
	if assert.Nil(t, err) {
		// We should only have two NewVulnerabilityNotification notifications: one for test1 and one for test2
		// We should not have a VulnerabilityPriorityIncreasedNotification or a VulnerabilityPackageChangedNotification
		// for test1 because it is in the same batch
		if assert.Len(t, notifications, 2) {
			for _, n := range notifications {
				_, ok := n.(*NewVulnerabilityNotification)
				assert.True(t, ok)
			}
		}
	}

	// VulnerabilityPriorityIncreasedNotification
	vuln1c := &Vulnerability{ID: "test1", Priority: types.Critical}
	notifications, err = InsertVulnerabilities([]*Vulnerability{vuln1c})
	if assert.Nil(t, err) {
		if assert.Len(t, notifications, 1) {
			if nn, ok := notifications[0].(*VulnerabilityPriorityIncreasedNotification); assert.True(t, ok) {
				assert.Equal(t, vuln1b.Priority, nn.OldPriority)
				assert.Equal(t, vuln1c.Priority, nn.NewPriority)
			}
		}
	}

	notifications, err = InsertVulnerabilities([]*Vulnerability{&Vulnerability{ID: "test1", Priority: types.Low}})
	assert.Nil(t, err)
	assert.Len(t, notifications, 0)

	// VulnerabilityPackageChangedNotification
	vuln1e := &Vulnerability{ID: "test1", FixedInNodes: []string{pkg1b.Node}}
	vuln1f := &Vulnerability{ID: "test1", FixedInNodes: []string{pkg2.Node}}
	notifications, err = InsertVulnerabilities([]*Vulnerability{vuln1e, vuln1f})
	if assert.Nil(t, err) {
		if assert.Len(t, notifications, 1) {
			if nn, ok := notifications[0].(*VulnerabilityPackageChangedNotification); assert.True(t, ok) {
				// Here, we say that pkg1b fixes the vulnerability, but as pkg1b is in
				// the same branch as pkg1, pkg1 should be removed and pkg1b added
				// We also add pkg2 as fixed
				assert.Contains(t, nn.AddedFixedInNodes, pkg1b.Node)
				assert.Contains(t, nn.RemovedFixedInNodes, pkg1.Node)

				assert.Contains(t, nn.AddedFixedInNodes, pkg2.Node)
			}
		}
	}
}

func TestDpkgFeatureDetection(t *testing.T) {
	testData := []feature.TestData{
		// Test an Ubuntu dpkg status file
		{
			FeatureVersions: []database.FeatureVersion{
				// Two packages from this source are installed, it should only appear one time
				{
					Feature: database.Feature{Name: "pam"},
					Version: types.NewVersionUnsafe("1.1.8-3.1ubuntu3"),
				},
				{
					Feature: database.Feature{Name: "makedev"},         // The source name and the package name are equals
					Version: types.NewVersionUnsafe("2.3.1-93ubuntu1"), // The version comes from the "Version:" line
				},
				{
					Feature: database.Feature{Name: "gcc-5"},
					Version: types.NewVersionUnsafe("5.1.1-12ubuntu1"), // The version comes from the "Source:" line
				},
			},
			Data: map[string][]byte{
				"var/lib/dpkg/status": feature.LoadFileForTest("dpkg/testdata/status"),
			},
		},
	}

	feature.TestDetector(t, &DpkgFeaturesDetector{}, testData)
}

func TestRpmFeatureDetection(t *testing.T) {
	testData := []feature.TestData{
		// Test a CentOS 7 RPM database
		// Memo: Use the following command on a RPM-based system to shrink a database: rpm -qa --qf "%{NAME}\n" |tail -n +3| xargs rpm -e --justdb
		{
			FeatureVersions: []database.FeatureVersion{
				// Two packages from this source are installed, it should only appear once
				{
					Feature: database.Feature{Name: "centos-release"},
					Version: types.NewVersionUnsafe("7-1.1503.el7.centos.2.8"),
				},
				// Two packages from this source are installed, it should only appear once
				{
					Feature: database.Feature{Name: "filesystem"},
					Version: types.NewVersionUnsafe("3.2-18.el7"),
				},
			},
			Data: map[string][]byte{
				"var/lib/rpm/Packages": feature.LoadFileForTest("rpm/testdata/Packages"),
			},
		},
	}

	feature.TestDetector(t, &RpmFeaturesDetector{}, testData)
}

func TestRHELParser(t *testing.T) {
	_, filename, _, _ := runtime.Caller(0)
	path := path.Join(path.Dir(filename))

	// Test parsing testdata/fetcher_rhel_test.1.xml
	testFile, _ := os.Open(path + "/testdata/fetcher_rhel_test.1.xml")
	vulnerabilities, err := parseRHSA(testFile)
	if assert.Nil(t, err) && assert.Len(t, vulnerabilities, 1) {
		assert.Equal(t, "RHSA-2015:1193", vulnerabilities[0].ID)
		assert.Equal(t, "https://rhn.redhat.com/errata/RHSA-2015-1193.html", vulnerabilities[0].Link)
		assert.Equal(t, types.Medium, vulnerabilities[0].Priority)
		assert.Equal(t, `Xerces-C is a validating XML parser written in a portable subset of C++. A flaw was found in the way the Xerces-C XML parser processed certain XML documents. A remote attacker could provide specially crafted XML input that, when parsed by an application using Xerces-C, would cause that application to crash.`, vulnerabilities[0].Description)

		if assert.Len(t, vulnerabilities[0].FixedIn, 3) {
			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
				OS:      "centos:7",
				Name:    "xerces-c",
				Version: types.NewVersionUnsafe("3.1.1-7.el7_1"),
			})
			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
				OS:      "centos:7",
				Name:    "xerces-c-devel",
				Version: types.NewVersionUnsafe("3.1.1-7.el7_1"),
			})
			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
				OS:      "centos:7",
				Name:    "xerces-c-doc",
				Version: types.NewVersionUnsafe("3.1.1-7.el7_1"),
			})
		}
	}

	// Test parsing testdata/fetcher_rhel_test.2.xml
	testFile, _ = os.Open(path + "/testdata/fetcher_rhel_test.2.xml")
	vulnerabilities, err = parseRHSA(testFile)
	if assert.Nil(t, err) && assert.Len(t, vulnerabilities, 1) {
		assert.Equal(t, "RHSA-2015:1207", vulnerabilities[0].ID)
		assert.Equal(t, "https://rhn.redhat.com/errata/RHSA-2015-1207.html", vulnerabilities[0].Link)
		assert.Equal(t, types.Critical, vulnerabilities[0].Priority)
		assert.Equal(t, `Mozilla Firefox is an open source web browser. XULRunner provides the XUL Runtime environment for Mozilla Firefox. Several flaws were found in the processing of malformed web content. A web page containing malicious content could cause Firefox to crash or, potentially, execute arbitrary code with the privileges of the user running Firefox.`, vulnerabilities[0].Description)

		if assert.Len(t, vulnerabilities[0].FixedIn, 2) {
			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
				OS:      "centos:6",
				Name:    "firefox",
				Version: types.NewVersionUnsafe("38.1.0-1.el6_6"),
			})
			assert.Contains(t, vulnerabilities[0].FixedIn, &database.Package{
				OS:      "centos:7",
				Name:    "firefox",
				Version: types.NewVersionUnsafe("38.1.0-1.el7_1"),
			})
		}
	}
}

func TestDebianParser(t *testing.T) {
	_, filename, _, _ := runtime.Caller(0)

	// Test parsing testdata/fetcher_debian_test.json
	testFile, _ := os.Open(path.Join(path.Dir(filename)) + "/testdata/fetcher_debian_test.json")
	response, err := buildResponse(testFile, "")
	if assert.Nil(t, err) && assert.Len(t, response.Vulnerabilities, 2) {
		for _, vulnerability := range response.Vulnerabilities {
			if vulnerability.ID == "CVE-2015-1323" {
				assert.Equal(t, "https://security-tracker.debian.org/tracker/CVE-2015-1323", vulnerability.Link)
				assert.Equal(t, types.Low, vulnerability.Priority)
				assert.Equal(t, "This vulnerability is not very dangerous.", vulnerability.Description)

				if assert.Len(t, vulnerability.FixedIn, 2) {
					assert.Contains(t, vulnerability.FixedIn, &database.Package{
						OS:      "debian:8",
						Name:    "aptdaemon",
						Version: types.MaxVersion,
					})
					assert.Contains(t, vulnerability.FixedIn, &database.Package{
						OS:      "debian:unstable",
						Name:    "aptdaemon",
						Version: types.NewVersionUnsafe("1.1.1+bzr982-1"),
					})
				}
			} else if vulnerability.ID == "CVE-2003-0779" {
				assert.Equal(t, "https://security-tracker.debian.org/tracker/CVE-2003-0779", vulnerability.Link)
				assert.Equal(t, types.High, vulnerability.Priority)
				assert.Equal(t, "But this one is very dangerous.", vulnerability.Description)

				if assert.Len(t, vulnerability.FixedIn, 3) {
					assert.Contains(t, vulnerability.FixedIn, &database.Package{
						OS:      "debian:8",
						Name:    "aptdaemon",
						Version: types.NewVersionUnsafe("0.7.0"),
					})
					assert.Contains(t, vulnerability.FixedIn, &database.Package{
						OS:      "debian:unstable",
						Name:    "aptdaemon",
						Version: types.NewVersionUnsafe("0.7.0"),
					})
					assert.Contains(t, vulnerability.FixedIn, &database.Package{
						OS:      "debian:8",
						Name:    "asterisk",
						Version: types.NewVersionUnsafe("0.5.56"),
					})
				}
			} else {
				assert.Fail(t, "Wrong vulnerability name: ", vulnerability.ID)
			}
		}
	}
}

func TestFindVulnerability(t *testing.T) {
	datastore, err := openDatabaseForTest("FindVulnerability", true)
	if err != nil {
		t.Error(err)
		return
	}
	defer datastore.Close()

	// Find a vulnerability that does not exist.
	_, err = datastore.FindVulnerability("", "")
	assert.Equal(t, cerrors.ErrNotFound, err)

	// Find a normal vulnerability.
	v1 := database.Vulnerability{
		Name:        "CVE-OPENSSL-1-DEB7",
		Description: "A vulnerability affecting OpenSSL < 2.0 on Debian 7.0",
		Link:        "http://google.com/#q=CVE-OPENSSL-1-DEB7",
		Severity:    types.High,
		Namespace:   database.Namespace{Name: "debian:7"},
		FixedIn: []database.FeatureVersion{
			{
				Feature: database.Feature{Name: "openssl"},
				Version: types.NewVersionUnsafe("2.0"),
			},
			{
				Feature: database.Feature{Name: "libssl"},
				Version: types.NewVersionUnsafe("1.9-abc"),
			},
		},
	}

	v1f, err := datastore.FindVulnerability("debian:7", "CVE-OPENSSL-1-DEB7")
	if assert.Nil(t, err) {
		equalsVuln(t, &v1, &v1f)
	}

	// Find a vulnerability that has no link, no severity and no FixedIn.
	v2 := database.Vulnerability{
		Name:        "CVE-NOPE",
		Description: "A vulnerability affecting nothing",
		Namespace:   database.Namespace{Name: "debian:7"},
		Severity:    types.Unknown,
	}

	v2f, err := datastore.FindVulnerability("debian:7", "CVE-NOPE")
	if assert.Nil(t, err) {
		equalsVuln(t, &v2, &v2f)
	}
}

func TestDistUpgrade(t *testing.T) {
	database.Open(&config.DatabaseConfig{Type: "memstore"})
	defer database.Close()

	_, f, _, _ := runtime.Caller(0)
	path := path.Join(path.Dir(f)) + "/testdata/DistUpgrade/"

	// blank.tar: MAINTAINER Quentin MACHU <quentin.machu.fr>
	// wheezy.tar: FROM debian:wheezy
	// jessie.tar: RUN sed -i "s/precise/trusty/" /etc/apt/sources.list && apt-get update && apt-get -y dist-upgrade
	assert.Nil(t, Process("blank", "", path+"blank.tar.gz", "Docker"))
	assert.Nil(t, Process("wheezy", "blank", path+"wheezy.tar.gz", "Docker"))
	assert.Nil(t, Process("jessie", "wheezy", path+"jessie.tar.gz", "Docker"))

	err := Process("blank", "", path+"blank.tar.gz", "")
	assert.Error(t, err, "could not process a layer which does not have a specified format")

	err = Process("blank", "", path+"blank.tar.gz", "invalid")
	assert.Error(t, err, "could not process a layer which does not have a supported format")

	wheezy, err := database.FindOneLayerByID("wheezy", database.FieldLayerAll)
	if assert.Nil(t, err) {
		assert.Equal(t, "debian:7", wheezy.OS)
		assert.Len(t, wheezy.InstalledPackagesNodes, 52)
		assert.Len(t, wheezy.RemovedPackagesNodes, 0)

		jessie, err := database.FindOneLayerByID("jessie", database.FieldLayerAll)
		if assert.Nil(t, err) {
			assert.Equal(t, "debian:8", jessie.OS)
			assert.Len(t, jessie.InstalledPackagesNodes, 66)
			assert.Len(t, jessie.RemovedPackagesNodes, 44)

			packageNodes, err := jessie.AllPackages()
			if assert.Nil(t, err) {
				// These packages haven't been upgraded
				nonUpgradedPackages := []database.Package{
					database.Package{Name: "libtext-wrapi18n-perl", Version: types.NewVersionUnsafe("0.06-7")},
					database.Package{Name: "libtext-charwidth-perl", Version: types.NewVersionUnsafe("0.04-7")},
					database.Package{Name: "libtext-iconv-perl", Version: types.NewVersionUnsafe("1.7-5")},
					database.Package{Name: "mawk", Version: types.NewVersionUnsafe("1.3.3-17")},
					database.Package{Name: "insserv", Version: types.NewVersionUnsafe("1.14.0-5")},
					database.Package{Name: "db", Version: types.NewVersionUnsafe("5.1.29-5")},
					database.Package{Name: "ustr", Version: types.NewVersionUnsafe("1.0.4-3")},
					database.Package{Name: "xz-utils", Version: types.NewVersionUnsafe("5.1.1alpha+20120614-2")},
				}
				for _, p := range nonUpgradedPackages {
					p.OS = "debian:7"
					assert.Contains(t, packageNodes, p.GetNode(), "Jessie layer doesn't have %s but it should.", p)
				}
				for _, p := range nonUpgradedPackages {
					p.OS = "debian:8"
					assert.NotContains(t, packageNodes, p.GetNode(), "Jessie layer has %s but it shouldn't.", p)
				}
			}
		}
	}
}

func TestUbuntuParser(t *testing.T) {
	_, filename, _, _ := runtime.Caller(0)
	path := filepath.Join(filepath.Dir(filename))

	// Test parsing testdata/fetcher_
	testData, _ := os.Open(path + "/testdata/fetcher_ubuntu_test.txt")
	defer testData.Close()
	vulnerability, unknownReleases, err := parseUbuntuCVE(testData)
	if assert.Nil(t, err) {
		assert.Equal(t, "CVE-2015-4471", vulnerability.Name)
		assert.Equal(t, types.Medium, vulnerability.Severity)
		assert.Equal(t, "Off-by-one error in the lzxd_decompress function in lzxd.c in libmspack before 0.5 allows remote attackers to cause a denial of service (buffer under-read and application crash) via a crafted CAB archive.", vulnerability.Description)

		// Unknown release (line 28)
		_, hasUnkownRelease := unknownReleases["unknown"]
		assert.True(t, hasUnkownRelease)

		expectedFeatureVersions := []database.FeatureVersion{
			{
				Feature: database.Feature{
					Namespace: database.Namespace{Name: "ubuntu:14.04"},
					Name:      "libmspack",
				},
				Version: types.MaxVersion,
			},
			{
				Feature: database.Feature{
					Namespace: database.Namespace{Name: "ubuntu:15.04"},
					Name:      "libmspack",
				},
				Version: types.NewVersionUnsafe("0.4-3"),
			},
			{
				Feature: database.Feature{
					Namespace: database.Namespace{Name: "ubuntu:15.10"},
					Name:      "libmspack-anotherpkg",
				},
				Version: types.NewVersionUnsafe("0.1"),
			},
		}

		for _, expectedFeatureVersion := range expectedFeatureVersions {
			assert.Contains(t, vulnerability.FixedIn, expectedFeatureVersion)
		}
	}
}

func TestDoVulnerabilitiesNamespacing(t *testing.T) {
	fv1 := database.FeatureVersion{
		Feature: database.Feature{
			Namespace: database.Namespace{Name: "Namespace1"},
			Name:      "Feature1",
		},
		Version: types.NewVersionUnsafe("0.1"),
	}

	fv2 := database.FeatureVersion{
		Feature: database.Feature{
			Namespace: database.Namespace{Name: "Namespace2"},
			Name:      "Feature1",
		},
		Version: types.NewVersionUnsafe("0.2"),
	}

	fv3 := database.FeatureVersion{
		Feature: database.Feature{
			Namespace: database.Namespace{Name: "Namespace2"},
			Name:      "Feature2",
		},
		Version: types.NewVersionUnsafe("0.3"),
	}

	vulnerability := database.Vulnerability{
		Name:    "DoVulnerabilityNamespacing",
		FixedIn: []database.FeatureVersion{fv1, fv2, fv3},
	}

	vulnerabilities := doVulnerabilitiesNamespacing([]database.Vulnerability{vulnerability})
	for _, vulnerability := range vulnerabilities {
		switch vulnerability.Namespace.Name {
		case fv1.Feature.Namespace.Name:
			assert.Len(t, vulnerability.FixedIn, 1)
			assert.Contains(t, vulnerability.FixedIn, fv1)
		case fv2.Feature.Namespace.Name:
			assert.Len(t, vulnerability.FixedIn, 2)
			assert.Contains(t, vulnerability.FixedIn, fv2)
			assert.Contains(t, vulnerability.FixedIn, fv3)
		default:
			t.Errorf("Should not have a Vulnerability with '%s' as its Namespace.", vulnerability.Namespace.Name)
			fmt.Printf("%#v\n", vulnerability)
		}
	}
}

func TestSLEParser(t *testing.T) {
	_, filename, _, _ := runtime.Caller(0)
	path := filepath.Join(filepath.Dir(filename))

	// Test parsing testdata/fetcher_sle_test.1.xml
	testFile, _ := os.Open(path + "/testdata/fetcher_sle_test.1.xml")
	ov := &oval.OvalFetcher{OsInfo: &SLEInfo{}}
	vulnerabilities, err := ov.ParseOval(testFile)
	if assert.Nil(t, err) && assert.Len(t, vulnerabilities, 1) {
		assert.Equal(t, "CVE-2012-2150", vulnerabilities[0].Name)
		assert.Equal(t, "http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-2150", vulnerabilities[0].Link)
		// Severity is not defined for SLE
		assert.Equal(t, types.Unknown, vulnerabilities[0].Severity)
		assert.Equal(t, `xfs_metadump in xfsprogs before 3.2.4 does not properly obfuscate file data, which allows remote attackers to obtain sensitive information by reading a generated image.`, vulnerabilities[0].Description)

		expectedFeatureVersions := []database.FeatureVersion{
			{
				Feature: database.Feature{
					Namespace: database.Namespace{Name: "sle:12"},
					Name:      "xfsprogs",
				},
				Version: types.NewVersionUnsafe("3.2.1-3.5"),
			},
			{
				Feature: database.Feature{
					Namespace: database.Namespace{Name: "sle:12.1"},
					Name:      "xfsprogs",
				},
				Version: types.NewVersionUnsafe("3.2.1-3.5"),
			},
		}

		for _, expectedFeatureVersion := range expectedFeatureVersions {
			assert.Contains(t, vulnerabilities[0].FixedIn, expectedFeatureVersion)
		}

	}

}

func testInsertLayerUpdate(t *testing.T, datastore database.Datastore) {
	f7 := database.FeatureVersion{
		Feature: database.Feature{
			Namespace: database.Namespace{Name: "TestInsertLayerNamespace3"},
			Name:      "TestInsertLayerFeature7",
		},
		Version: types.NewVersionUnsafe("0.01"),
	}

	l3, _ := datastore.FindLayer("TestInsertLayer3", true, false)
	l3u := database.Layer{
		Name:      l3.Name,
		Parent:    l3.Parent,
		Namespace: &database.Namespace{Name: "TestInsertLayerNamespaceUpdated1"},
		Features:  []database.FeatureVersion{f7},
	}

	l4u := database.Layer{
		Name:          "TestInsertLayer4",
		Parent:        &database.Layer{Name: "TestInsertLayer3"},
		Features:      []database.FeatureVersion{f7},
		EngineVersion: 2,
	}

	// Try to re-insert without increasing the EngineVersion.
	err := datastore.InsertLayer(l3u)
	assert.Nil(t, err)

	l3uf, err := datastore.FindLayer(l3u.Name, true, false)
	if assert.Nil(t, err) {
		assert.Equal(t, l3.Namespace.Name, l3uf.Namespace.Name)
		assert.Equal(t, l3.EngineVersion, l3uf.EngineVersion)
		assert.Len(t, l3uf.Features, len(l3.Features))
	}

	// Update layer l3.
	// Verify that the Namespace, EngineVersion and FeatureVersions got updated.
	l3u.EngineVersion = 2
	err = datastore.InsertLayer(l3u)
	assert.Nil(t, err)

	l3uf, err = datastore.FindLayer(l3u.Name, true, false)
	if assert.Nil(t, err) {
		assert.Equal(t, l3u.Namespace.Name, l3uf.Namespace.Name)
		assert.Equal(t, l3u.EngineVersion, l3uf.EngineVersion)
		if assert.Len(t, l3uf.Features, 1) {
			assert.True(t, cmpFV(l3uf.Features[0], f7), "Updated layer should have %#v but actually have %#v", f7, l3uf.Features[0])
		}
	}

	// Update layer l4.
	// Verify that the Namespace got updated from its new Parent's, and also verify the
	// EnginVersion and FeatureVersions.
	l4u.Parent = &l3uf
	err = datastore.InsertLayer(l4u)
	assert.Nil(t, err)

	l4uf, err := datastore.FindLayer(l3u.Name, true, false)
	if assert.Nil(t, err) {
		assert.Equal(t, l3u.Namespace.Name, l4uf.Namespace.Name)
		assert.Equal(t, l4u.EngineVersion, l4uf.EngineVersion)
		if assert.Len(t, l4uf.Features, 1) {
			assert.True(t, cmpFV(l3uf.Features[0], f7), "Updated layer should have %#v but actually have %#v", f7, l4uf.Features[0])
		}
	}
}

func TestProcessWithDistUpgrade(t *testing.T) {
	// TODO(Quentin-M): This should not be bound to a single database implementation.
	datastore, err := pgsql.OpenForTest("ProcessWithDistUpgrade", false)
	if err != nil {
		t.Error(err)
		return
	}
	defer datastore.Close()

	_, f, _, _ := runtime.Caller(0)
	path := path.Join(path.Dir(f)) + "/testdata/DistUpgrade/"

	// blank.tar: MAINTAINER Quentin MACHU <quentin.machu.fr>
	// wheezy.tar: FROM debian:wheezy
	// jessie.tar: RUN sed -i "s/precise/trusty/" /etc/apt/sources.list && apt-get update &&
	//             apt-get -y dist-upgrade
	assert.Nil(t, Process(datastore, "Docker", "blank", "", path+"blank.tar.gz", nil))
	assert.Nil(t, Process(datastore, "Docker", "wheezy", "blank", path+"wheezy.tar.gz", nil))
	assert.Nil(t, Process(datastore, "Docker", "jessie", "wheezy", path+"jessie.tar.gz", nil))

	wheezy, err := datastore.FindLayer("wheezy", true, false)
	if assert.Nil(t, err) {
		assert.Equal(t, "debian:7", wheezy.Namespace.Name)
		assert.Len(t, wheezy.Features, 52)

		jessie, err := datastore.FindLayer("jessie", true, false)
		if assert.Nil(t, err) {
			assert.Equal(t, "debian:8", jessie.Namespace.Name)
			assert.Len(t, jessie.Features, 74)

			// These FeatureVersions haven't been upgraded.
			nonUpgradedFeatureVersions := []database.FeatureVersion{
				{
					Feature: database.Feature{Name: "libtext-wrapi18n-perl"},
					Version: types.NewVersionUnsafe("0.06-7"),
				},
				{
					Feature: database.Feature{Name: "libtext-charwidth-perl"},
					Version: types.NewVersionUnsafe("0.04-7"),
				},
				{
					Feature: database.Feature{Name: "libtext-iconv-perl"},
					Version: types.NewVersionUnsafe("1.7-5"),
				},
				{
					Feature: database.Feature{Name: "mawk"},
					Version: types.NewVersionUnsafe("1.3.3-17"),
				},
				{
					Feature: database.Feature{Name: "insserv"},
					Version: types.NewVersionUnsafe("1.14.0-5"),
				},
				{
					Feature: database.Feature{Name: "db"},
					Version: types.NewVersionUnsafe("5.1.29-5"),
				},
				{
					Feature: database.Feature{Name: "ustr"},
					Version: types.NewVersionUnsafe("1.0.4-3"),
				},
				{
					Feature: database.Feature{Name: "xz-utils"},
					Version: types.NewVersionUnsafe("5.1.1alpha+20120614-2"),
				},
			}

			for _, nufv := range nonUpgradedFeatureVersions {
				nufv.Feature.Namespace.Name = "debian:7"

				found := false
				for _, fv := range jessie.Features {
					if fv.Feature.Name == nufv.Feature.Name &&
						fv.Feature.Namespace.Name == nufv.Feature.Namespace.Name &&
						fv.Version == nufv.Version {
						found = true
						break
					}
				}
				assert.Equal(t, true, found, "Jessie layer doesn't have %#v but it should.", nufv)
			}

			for _, nufv := range nonUpgradedFeatureVersions {
				nufv.Feature.Namespace.Name = "debian:8"

				found := false
				for _, fv := range jessie.Features {
					if fv.Feature.Name == nufv.Feature.Name &&
						fv.Feature.Namespace.Name == nufv.Feature.Namespace.Name &&
						fv.Version == nufv.Version {
						found = true
						break
					}
				}
				assert.Equal(t, false, found, "Jessie layer has %#v but it shouldn't.", nufv)
			}
		}
	}
}

func TestNotification(t *testing.T) {
	datastore, err := openDatabaseForTest("Notification", false)
	if err != nil {
		t.Error(err)
		return
	}
	defer datastore.Close()

	// Try to get a notification when there is none.
	_, err = datastore.GetAvailableNotification(time.Second)
	assert.Equal(t, cerrors.ErrNotFound, err)

	// Create some data.
	f1 := database.Feature{
		Name:      "TestNotificationFeature1",
		Namespace: database.Namespace{Name: "TestNotificationNamespace1"},
	}

	f2 := database.Feature{
		Name:      "TestNotificationFeature2",
		Namespace: database.Namespace{Name: "TestNotificationNamespace1"},
	}

	l1 := database.Layer{
		Name: "TestNotificationLayer1",
		Features: []database.FeatureVersion{
			{
				Feature: f1,
				Version: types.NewVersionUnsafe("0.1"),
			},
		},
	}

	l2 := database.Layer{
		Name: "TestNotificationLayer2",
		Features: []database.FeatureVersion{
			{
				Feature: f1,
				Version: types.NewVersionUnsafe("0.2"),
			},
		},
	}

	l3 := database.Layer{
		Name: "TestNotificationLayer3",
		Features: []database.FeatureVersion{
			{
				Feature: f1,
				Version: types.NewVersionUnsafe("0.3"),
			},
		},
	}

	l4 := database.Layer{
		Name: "TestNotificationLayer4",
		Features: []database.FeatureVersion{
			{
				Feature: f2,
				Version: types.NewVersionUnsafe("0.1"),
			},
		},
	}

	if !assert.Nil(t, datastore.InsertLayer(l1)) ||
		!assert.Nil(t, datastore.InsertLayer(l2)) ||
		!assert.Nil(t, datastore.InsertLayer(l3)) ||
		!assert.Nil(t, datastore.InsertLayer(l4)) {
		return
	}

	// Insert a new vulnerability that is introduced by three layers.
	v1 := database.Vulnerability{
		Name:        "TestNotificationVulnerability1",
		Namespace:   f1.Namespace,
		Description: "TestNotificationDescription1",
		Link:        "TestNotificationLink1",
		Severity:    "Unknown",
		FixedIn: []database.FeatureVersion{
			{
				Feature: f1,
				Version: types.NewVersionUnsafe("1.0"),
			},
		},
	}
	assert.Nil(t, datastore.insertVulnerability(v1, false, true))

	// Get the notification associated to the previously inserted vulnerability.
	notification, err := datastore.GetAvailableNotification(time.Second)

	if assert.Nil(t, err) && assert.NotEmpty(t, notification.Name) {
		// Verify the renotify behaviour.
		if assert.Nil(t, datastore.SetNotificationNotified(notification.Name)) {
			_, err := datastore.GetAvailableNotification(time.Second)
			assert.Equal(t, cerrors.ErrNotFound, err)

			time.Sleep(50 * time.Millisecond)
			notificationB, err := datastore.GetAvailableNotification(20 * time.Millisecond)
			assert.Nil(t, err)
			assert.Equal(t, notification.Name, notificationB.Name)

//.........这里部分代码省略.........

func TestPackage(t *testing.T) {
	Open("memstore", "")
	defer Close()

	// Try to insert invalid packages
	for _, invalidPkg := range []*Package{
		&Package{OS: "", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")},
		&Package{OS: "testOS", Name: "", Version: types.NewVersionUnsafe("1.0")},
		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("")},
		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("bad version")},
		&Package{OS: "", Name: "", Version: types.NewVersionUnsafe("")},
	} {
		err := InsertPackages([]*Package{invalidPkg})
		assert.Error(t, err)
	}

	// Insert a package
	pkg1 := &Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")}
	err := InsertPackages([]*Package{pkg1})
	if assert.Nil(t, err) {
		// Find the inserted package and verify its content
		pkg1b, err := FindOnePackage(pkg1.OS, pkg1.Name, pkg1.Version, FieldPackageAll)
		if assert.Nil(t, err) && assert.NotNil(t, pkg1b) {
			assert.Equal(t, pkg1.Node, pkg1b.Node)
			assert.Equal(t, pkg1.OS, pkg1b.OS)
			assert.Equal(t, pkg1.Name, pkg1b.Name)
			assert.Equal(t, pkg1.Version, pkg1b.Version)
		}

		// Find packages from the inserted branch and verify their content
		// (the first one should be a start package, the second one the inserted one and the third one the end package)
		pkgs1c, err := FindAllPackagesByBranch(pkg1.OS, pkg1.Name, FieldPackageAll)
		if assert.Nil(t, err) && assert.Equal(t, 3, len(pkgs1c)) {
			sort.Sort(ByVersion(pkgs1c))

			assert.Equal(t, pkg1.OS, pkgs1c[0].OS)
			assert.Equal(t, pkg1.Name, pkgs1c[0].Name)
			assert.Equal(t, types.MinVersion, pkgs1c[0].Version)

			assert.Equal(t, pkg1.OS, pkgs1c[1].OS)
			assert.Equal(t, pkg1.Name, pkgs1c[1].Name)
			assert.Equal(t, pkg1.Version, pkgs1c[1].Version)

			assert.Equal(t, pkg1.OS, pkgs1c[2].OS)
			assert.Equal(t, pkg1.Name, pkgs1c[2].Name)
			assert.Equal(t, types.MaxVersion, pkgs1c[2].Version)
		}
	}

	// Insert multiple packages in the same branch, one in another branch, insert local duplicates and database duplicates as well
	pkg2 := []*Package{
		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("0.8")},
		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("0.9")},
		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.0")}, // Already present in the database
		&Package{OS: "testOS", Name: "testpkg1", Version: types.NewVersionUnsafe("1.1")},
		&Package{OS: "testOS", Name: "testpkg2", Version: types.NewVersionUnsafe("1.0")}, // Another branch
		&Package{OS: "testOS", Name: "testpkg2", Version: types.NewVersionUnsafe("1.0")}, // Local duplicates
	}
	nbInSameBranch := 4 + 2 // (start/end packages)

	err = InsertPackages(shuffle(pkg2))
	if assert.Nil(t, err) {
		// Find packages from the inserted branch, verify their order and NextVersion / PreviousVersion
		pkgs2b, err := FindAllPackagesByBranch("testOS", "testpkg1", FieldPackageAll)
		if assert.Nil(t, err) && assert.Equal(t, nbInSameBranch, len(pkgs2b)) {
			sort.Sort(ByVersion(pkgs2b))

			for i := 0; i < nbInSameBranch; i = i + 1 {
				if i == 0 {
					assert.Equal(t, types.MinVersion, pkgs2b[0].Version)
				} else if i < nbInSameBranch-2 {
					assert.Equal(t, pkg2[i].Version, pkgs2b[i+1].Version)

					nv, err := pkgs2b[i+1].NextVersion(FieldPackageAll)
					assert.Nil(t, err)
					assert.Equal(t, pkgs2b[i+2], nv)

					if i > 0 {
						pv, err := pkgs2b[i].PreviousVersion(FieldPackageAll)
						assert.Nil(t, err)
						assert.Equal(t, pkgs2b[i-1], pv)
					} else {
						pv, err := pkgs2b[i].PreviousVersion(FieldPackageAll)
						assert.Nil(t, err)
						assert.Nil(t, pv)
					}
				} else {
					assert.Equal(t, types.MaxVersion, pkgs2b[nbInSameBranch-1].Version)

					nv, err := pkgs2b[nbInSameBranch-1].NextVersion(FieldPackageAll)
					assert.Nil(t, err)
					assert.Nil(t, nv)

					pv, err := pkgs2b[i].PreviousVersion(FieldPackageAll)
					assert.Nil(t, err)
					assert.Equal(t, pkgs2b[i-1], pv)
				}
			}

			// NextVersions
//.........这里部分代码省略.........

func TestInsertFeature(t *testing.T) {
	datastore, err := OpenForTest("InsertFeature", false)
	if err != nil {
		t.Error(err)
		return
	}
	defer datastore.Close()

	// Invalid Feature.
	id0, err := datastore.insertFeature(database.Feature{})
	assert.NotNil(t, err)
	assert.Zero(t, id0)

	id0, err = datastore.insertFeature(database.Feature{
		Namespace: database.Namespace{},
		Name:      "TestInsertFeature0",
	})
	assert.NotNil(t, err)
	assert.Zero(t, id0)

	// Insert Feature and ensure we can find it.
	feature := database.Feature{
		Namespace: database.Namespace{Name: "TestInsertFeatureNamespace1"},
		Name:      "TestInsertFeature1",
	}
	id1, err := datastore.insertFeature(feature)
	assert.Nil(t, err)
	id2, err := datastore.insertFeature(feature)
	assert.Nil(t, err)
	assert.Equal(t, id1, id2)

	// Insert invalid FeatureVersion.
	for _, invalidFeatureVersion := range []database.FeatureVersion{
		{
			Feature: database.Feature{},
			Version: types.NewVersionUnsafe("1.0"),
		},
		{
			Feature: database.Feature{
				Namespace: database.Namespace{},
				Name:      "TestInsertFeature2",
			},
			Version: types.NewVersionUnsafe("1.0"),
		},
		{
			Feature: database.Feature{
				Namespace: database.Namespace{Name: "TestInsertFeatureNamespace2"},
				Name:      "TestInsertFeature2",
			},
			Version: types.NewVersionUnsafe(""),
		},
		{
			Feature: database.Feature{
				Namespace: database.Namespace{Name: "TestInsertFeatureNamespace2"},
				Name:      "TestInsertFeature2",
			},
			Version: types.NewVersionUnsafe("bad version"),
		},
	} {
		id3, err := datastore.insertFeatureVersion(invalidFeatureVersion)
		assert.Error(t, err)
		assert.Zero(t, id3)
	}

	// Insert FeatureVersion and ensure we can find it.
	featureVersion := database.FeatureVersion{
		Feature: database.Feature{
			Namespace: database.Namespace{Name: "TestInsertFeatureNamespace1"},
			Name:      "TestInsertFeature1",
		},
		Version: types.NewVersionUnsafe("2:3.0-imba"),
	}
	id4, err := datastore.insertFeatureVersion(featureVersion)
	assert.Nil(t, err)
	id5, err := datastore.insertFeatureVersion(featureVersion)
	assert.Nil(t, err)
	assert.Equal(t, id4, id5)
}