Merge pull request #69 from rusenask/feature/wrong_version_bugfix

Feature/wrong version bugfix

provider/kubernetes/kubernetes_test.go

@@ -318,6 +318,64 @@ func TestProcessEvent(t *testing.T) {
 	}
 }
 
+func TestProcessEventBuildNumber(t *testing.T) {
+	fp := &fakeImplementer{}
+	fp.namespaces = &v1.NamespaceList{
+		Items: []v1.Namespace{
+			v1.Namespace{
+				meta_v1.TypeMeta{},
+				meta_v1.ObjectMeta{Name: "xxxx"},
+				v1.NamespaceSpec{},
+				v1.NamespaceStatus{},
+			},
+		},
+	}
+	fp.deploymentList = &v1beta1.DeploymentList{
+		Items: []v1beta1.Deployment{
+			v1beta1.Deployment{
+				meta_v1.TypeMeta{},
+				meta_v1.ObjectMeta{
+					Name:      "deployment-1",
+					Namespace: "xxxx",
+					Labels:    map[string]string{types.KeelPolicyLabel: "all"},
+				},
+				v1beta1.DeploymentSpec{
+					Template: v1.PodTemplateSpec{
+						Spec: v1.PodSpec{
+							Containers: []v1.Container{
+								v1.Container{
+									Image: "gcr.io/v2-namespace/hello-world:10",
+								},
+							},
+						},
+					},
+				},
+				v1beta1.DeploymentStatus{},
+			},
+		},
+	}
+
+	provider, err := NewProvider(fp, &fakeSender{})
+	if err != nil {
+		t.Fatalf("failed to get provider: %s", err)
+	}
+
+	repo := types.Repository{
+		Name: "gcr.io/v2-namespace/hello-world",
+		Tag:  "11",
+	}
+
+	event := &types.Event{Repository: repo}
+	_, err = provider.processEvent(event)
+	if err != nil {
+		t.Errorf("got error while processing event: %s", err)
+	}
+
+	if fp.updated.Spec.Template.Spec.Containers[0].Image != repo.Name+":"+repo.Tag {
+		t.Errorf("expected to find a deployment with updated image but found: %s", fp.updated.Spec.Template.Spec.Containers[0].Image)
+	}
+}
+
 // Test to check how many deployments are "impacted" if we have sidecar container
 func TestGetImpactedTwoContainersInSameDeployment(t *testing.T) {
 	fp := &fakeImplementer{}

types/types.go

@@ -50,14 +50,14 @@ type Version struct {
 	PreRelease string
 	Metadata   string
 
-	Prefix string // v prefix
+	Original string
 }
 
 func (v Version) String() string {
-	var buf bytes.Buffer
-	if v.Prefix != "" {
-		fmt.Fprintf(&buf, v.Prefix)
+	if v.Original != "" {
+		return v.Original
 	}
+	var buf bytes.Buffer
 
 	fmt.Fprintf(&buf, "%d.%d.%d", v.Major, v.Minor, v.Patch)
 	if v.PreRelease != "" {
@@ -68,6 +68,7 @@ func (v Version) String() string {
 	}
 
 	return buf.String()
+
 }
 
 // TriggerType - trigger types

types/types_test.go

@@ -60,7 +60,7 @@ func TestVersion_String(t *testing.T) {
 		Patch      int64
 		PreRelease string
 		Metadata   string
-		Prefix     string
+		Original   string
 	}
 	tests := []struct {
 		name   string
@@ -70,19 +70,20 @@ func TestVersion_String(t *testing.T) {
 		{
 			name: "semver with v",
 			fields: fields{
-				Major:  1,
-				Minor:  1,
-				Patch:  0,
-				Prefix: "v",
+				Major:    1,
+				Minor:    1,
+				Patch:    0,
+				Original: "v1.1.0",
 			},
 			want: "v1.1.0",
 		},
 		{
 			name: "semver standard",
 			fields: fields{
-				Major: 1,
-				Minor: 1,
-				Patch: 5,
+				Major:    1,
+				Minor:    1,
+				Patch:    5,
+				Original: "1.1.5",
 			},
 			want: "1.1.5",
 		},
@@ -95,7 +96,7 @@ func TestVersion_String(t *testing.T) {
 				Patch:      tt.fields.Patch,
 				PreRelease: tt.fields.PreRelease,
 				Metadata:   tt.fields.Metadata,
-				Prefix:     tt.fields.Prefix,
+				Original:   tt.fields.Original,
 			}
 			if got := v.String(); got != tt.want {
 				t.Errorf("Version.String() = %v, want %v", got, tt.want)

util/version/version.go

@@ -19,6 +19,15 @@ var ErrVersionTagMissing = errors.New("version tag is missing")
 // being parsed.
 var ErrInvalidSemVer = errors.New("invalid semantic version")
 
+// MustParse - must parse version, if fails - panics
+func MustParse(version string) *types.Version {
+	ver, err := GetVersion(version)
+	if err != nil {
+		panic(err)
+	}
+	return ver
+}
+
 // GetVersion - parse version
 func GetVersion(version string) (*types.Version, error) {
 
@@ -29,11 +38,6 @@ func GetVersion(version string) (*types.Version, error) {
 		}
 		return nil, err
 	}
-	// TODO: probably make it customazible
-	prefix := ""
-	if strings.HasPrefix(version, "v") {
-		prefix = "v"
-	}
 
 	return &types.Version{
 		Major:      v.Major(),
@@ -41,7 +45,7 @@ func GetVersion(version string) (*types.Version, error) {
 		Patch:      v.Patch(),
 		PreRelease: string(v.Prerelease()),
 		Metadata:   v.Metadata(),
-		Prefix:     prefix,
+		Original:   v.Original(),
 	}, nil
 }
 

util/version/version_test.go

@@ -20,13 +20,13 @@ func TestGetVersionFromImageName(t *testing.T) {
 		{
 			name:    "image",
 			args:    args{name: "karolis/webhook-demo:1.4.5"},
-			want:    &types.Version{Major: 1, Minor: 4, Patch: 5},
+			want:    MustParse("1.4.5"),
 			wantErr: false,
 		},
 		{
 			name:    "semver with v prefix",
 			args:    args{name: "gcr.io/stemnapp/alpine-api:v0.0.824"},
-			want:    &types.Version{Major: 0, Minor: 0, Patch: 824, Prefix: "v"},
+			want:    MustParse("v0.0.824"),
 			wantErr: false,
 		},
 		{
@@ -42,7 +42,18 @@ func TestGetVersionFromImageName(t *testing.T) {
 		{
 			name:    "image webhookrelay",
 			args:    args{name: "gcr.io/webhookrelay/webhookrelay:0.1.14"},
-			want:    &types.Version{Major: 0, Minor: 1, Patch: 14},
+			want:    MustParse("0.1.14"),
+			wantErr: false,
+		},
+		{
+			name: "non semver, missing minor and patch",
+			args: args{name: "index.docker.io/application:42"},
+			want: &types.Version{
+				Major:    42,
+				Minor:    0,
+				Patch:    0,
+				Original: "42",
+			},
 			wantErr: false,
 		},
 	}
@@ -282,3 +293,61 @@ func TestNewAvailable(t *testing.T) {
 		})
 	}
 }
+
+func TestGetVersion(t *testing.T) {
+	type args struct {
+		version string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *types.Version
+		wantErr bool
+	}{
+		{
+			name: "normal version",
+			args: args{version: "1.2.3"},
+			want: &types.Version{
+				Major:    1,
+				Minor:    2,
+				Patch:    3,
+				Original: "1.2.3",
+			},
+			wantErr: false,
+		},
+		{
+			name: "legacy semver version",
+			args: args{version: "v1.2.3"},
+			want: &types.Version{
+				Major:    1,
+				Minor:    2,
+				Patch:    3,
+				Original: "v1.2.3",
+			},
+			wantErr: false,
+		},
+		{
+			name: "not semver",
+			args: args{version: "23"},
+			want: &types.Version{
+				Major:    23,
+				Minor:    0,
+				Patch:    0,
+				Original: "23",
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := GetVersion(tt.args.version)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetVersion() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetVersion() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}