//VerifyImagesSame will take the two supplied image tags and see if they reference the same hexadecimal image ID; strategy is for debug
func VerifyImagesSame(comp1, comp2, strategy string) {
tag1 := comp1 + ":latest"
tag2 := comp2 + ":latest"
comps := []string{tag1, tag2}
retIDs, gerr := GetImageIDForTags(comps)
o.Expect(gerr).NotTo(o.HaveOccurred())
fmt.Fprintf(g.GinkgoWriter, "%s compare image - %s, %s, %s, %s", strategy, tag1, tag2, retIDs[0], retIDs[1])
o.Ω(len(retIDs[0])).Should(o.BeNumerically(">", 0))
o.Ω(len(retIDs[1])).Should(o.BeNumerically(">", 0))
o.Ω(retIDs[0]).Should(o.Equal(retIDs[1]))
}
//VerifyImagesDifferent will that the two supplied image tags and see if they reference different hexadecimal image IDs; strategy is for ginkgo debug, also leverage ginkgo error checking
func VerifyImagesDifferent(comp1, comp2, strategy string) {
tag1 := comp1 + ":latest"
tag2 := comp2 + ":latest"
comps := []string{tag1, tag2}
retIDs, gerr := GetImageIDForTags(comps)
o.Expect(gerr).NotTo(o.HaveOccurred())
g.By(fmt.Sprintf("%s compare image - %s, %s, %s, %s", strategy, tag1, tag2, retIDs[0], retIDs[1]))
o.Ω(len(retIDs[0])).Should(o.BeNumerically(">", 0))
o.Ω(len(retIDs[1])).Should(o.BeNumerically(">", 0))
o.Ω(retIDs[0] != retIDs[1]).Should(o.BeTrue())
}
//VerifyImagesSame will take the two supplied image tags and see if they reference the same hexadecimal image ID; strategy is for debug
func VerifyImagesSame(comp1, comp2, strategy string) {
tag1 := comp1 + ":latest"
tag2 := comp2 + ":latest"
comps := []string{tag1, tag2}
retIDs, gerr := GetImageIDForTags(comps)
o.Expect(gerr).NotTo(o.HaveOccurred())
g.By(fmt.Sprintf("\n%s %s compare image - %s, %s, %s, %s", time.Now().Format(time.RFC850), strategy, tag1, tag2, retIDs[0], retIDs[1]))
o.Ω(len(retIDs[0])).Should(o.BeNumerically(">", 0))
o.Ω(len(retIDs[1])).Should(o.BeNumerically(">", 0))
o.Ω(retIDs[0]).Should(o.Equal(retIDs[1]))
}
func (d TableDurationWithDelta) MatchString(actual string) error {
if !strings.HasSuffix(actual, d.Suffix) {
return fmt.Errorf("expected %s to have suffix %s", actual, d.Suffix)
}
actualDuration, _ := time.ParseDuration(strings.TrimSuffix(actual, d.Suffix))
matched, err := gomega.BeNumerically("~", d.Delta, d.Duration).Match(actualDuration)
if err != nil {
return err
}
if !matched {
return fmt.Errorf("expected duration %s is not within delta %s of actual duration %s", d.Duration, d.Delta, actualDuration)
}
return nil
}
o.Expect(out).To(o.ContainSubstring("updated"))
}
o.Expect(waitForLatestCondition(oc, "history-limit", deploymentRunTimeout, checkDeploymentConfigHasSynced)).NotTo(o.HaveOccurred(),
"the controller needs to have synced with the updated deployment configuration before checking that the revision history limits are being adhered to")
deploymentConfig, deployments, _, err := deploymentInfo(oc, "history-limit")
o.Expect(err).NotTo(o.HaveOccurred())
// sanity check to ensure that the following asertion on the amount of old deployments is valid
o.Expect(*deploymentConfig.Spec.RevisionHistoryLimit).To(o.Equal(int32(revisionHistoryLimit)))
// we need to filter out any deployments that we don't care about,
// namely the active deployment and any newer deployments
oldDeployments := deployutil.DeploymentsForCleanup(deploymentConfig, deployments)
// we should not have more deployments than acceptable
o.Expect(len(oldDeployments)).To(o.BeNumerically("==", revisionHistoryLimit))
// the deployments we continue to keep should be the latest ones
for _, deployment := range oldDeployments {
o.Expect(deployutil.DeploymentVersionFor(&deployment)).To(o.BeNumerically(">=", iterations-revisionHistoryLimit))
}
})
})
g.Describe("with minimum ready seconds set", func() {
g.AfterEach(func() {
failureTrap(oc, "minreadytest", g.CurrentGinkgoTestDescription().Failed)
})
g.It("should not transition the deployment to Complete before satisfied [Conformance]", func() {
_, name, err := createFixture(oc, minReadySecondsFixture)
func matcherToGomegaMatcher(matcher interface{}) (types.GomegaMatcher, error) {
switch x := matcher.(type) {
case string, int, bool, float64:
return gomega.Equal(x), nil
case []interface{}:
var matchers []types.GomegaMatcher
for _, valueI := range x {
if subMatcher, ok := valueI.(types.GomegaMatcher); ok {
matchers = append(matchers, subMatcher)
} else {
matchers = append(matchers, gomega.ContainElement(valueI))
}
}
return gomega.And(matchers...), nil
}
matcher = sanitizeExpectedValue(matcher)
if matcher == nil {
return nil, fmt.Errorf("Missing Required Attribute")
}
matcherMap, ok := matcher.(map[string]interface{})
if !ok {
panic(fmt.Sprintf("Unexpected matcher type: %T\n\n", matcher))
}
var matchType string
var value interface{}
for matchType, value = range matcherMap {
break
}
switch matchType {
case "have-prefix":
return gomega.HavePrefix(value.(string)), nil
case "have-suffix":
return gomega.HaveSuffix(value.(string)), nil
case "match-regexp":
return gomega.MatchRegexp(value.(string)), nil
case "have-len":
value = sanitizeExpectedValue(value)
return gomega.HaveLen(value.(int)), nil
case "contain-element":
subMatcher, err := matcherToGomegaMatcher(value)
if err != nil {
return nil, err
}
return gomega.ContainElement(subMatcher), nil
case "not":
subMatcher, err := matcherToGomegaMatcher(value)
if err != nil {
return nil, err
}
return gomega.Not(subMatcher), nil
case "consist-of":
subMatchers, err := sliceToGomega(value)
if err != nil {
return nil, err
}
var interfaceSlice []interface{}
for _, d := range subMatchers {
interfaceSlice = append(interfaceSlice, d)
}
return gomega.ConsistOf(interfaceSlice...), nil
case "and":
subMatchers, err := sliceToGomega(value)
if err != nil {
return nil, err
}
return gomega.And(subMatchers...), nil
case "or":
subMatchers, err := sliceToGomega(value)
if err != nil {
return nil, err
}
return gomega.Or(subMatchers...), nil
case "gt", "ge", "lt", "le":
// Golang json escapes '>', '<' symbols, so we use 'gt', 'le' instead
comparator := map[string]string{
"gt": ">",
"ge": ">=",
"lt": "<",
"le": "<=",
}[matchType]
return gomega.BeNumerically(comparator, value), nil
default:
return nil, fmt.Errorf("Unknown matcher: %s", matchType)
}
}
func imageMetadataNotEmpty(image *imageapi.Image) {
o.Expect(len(image.DockerImageMetadata.ID)).Should(o.BeNumerically(">", 0))
o.Expect(len(image.DockerImageMetadata.Container)).Should(o.BeNumerically(">", 0))
o.Expect(len(image.DockerImageMetadata.DockerVersion)).Should(o.BeNumerically(">", 0))
o.Expect(len(image.DockerImageMetadata.Architecture)).Should(o.BeNumerically(">", 0))
}
imageDigest, err := imagesutil.BuildAndPushImageOfSizeWithDocker(oc, dClient, repoName, tagName, imageSize, 1, g.GinkgoWriter, true)
o.Expect(err).NotTo(o.HaveOccurred())
g.By("checking that the image converted...")
image, err := oc.AsAdmin().Client().Images().Get(imageDigest)
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(len(image.DockerImageManifest)).Should(o.Equal(0))
imageMetadataNotEmpty(image)
g.By("getting image manifest from docker-registry...")
conn, err := regclient.NewClient(10*time.Second, true).Connect(registryURL, true)
o.Expect(err).NotTo(o.HaveOccurred())
_, manifest, err := conn.ImageManifest(oc.Namespace(), repoName, tagName)
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(len(manifest)).Should(o.BeNumerically(">", 0))
g.By("restoring manifest...")
image, err = oc.AsAdmin().Client().Images().Get(imageDigest)
o.Expect(err).NotTo(o.HaveOccurred())
imageMetadataNotEmpty(image)
image.DockerImageManifest = string(manifest)
newImage, err := oc.AsAdmin().Client().Images().Update(image)
o.Expect(err).NotTo(o.HaveOccurred())
imageMetadataNotEmpty(newImage)
g.By("checking that the manifest is present in the image...")
image, err = oc.AsAdmin().Client().Images().Get(imageDigest)
o.Expect(err).NotTo(o.HaveOccurred())
{
in: `true`,
want: gomega.Equal(true),
},
// Default for Array
{
in: `["foo", "bar"]`,
want: gomega.And(gomega.ContainElement("foo"), gomega.ContainElement("bar")),
useNegateTester: true,
},
// Numeric
// Golang json escapes '>', '<' symbols, so we use 'gt', 'le' instead
{
in: `{"gt": 1}`,
want: gomega.BeNumerically(">", float64(1)),
},
{
in: `{"ge": 1}`,
want: gomega.BeNumerically(">=", float64(1)),
},
{
in: `{"lt": 1}`,
want: gomega.BeNumerically("<", float64(1)),
},
{
in: `{"le": 1}`,
want: gomega.BeNumerically("<=", float64(1)),
},
// String