972678690

Committed 18 Aug 2023 07:14PM UTC coverage: 79.678% (+0.07%) from 79.613%

Build # 972678690

Build Type

Pull #901

gitlab-ci

Committed by

merlin-northern

Commit Message

test: docs and acc test

Ticket: MEN-6623
Signed-off-by: Peter Grzybowski <peter@northern.tech>

Pull Request Pull Request #901: feat: save and get the update types

Run Details

74 of 85 new or added lines in 4 files covered. (87.06%)

391 existing lines in 3 files now uncovered.

7810 of 9802 relevant lines covered (79.68%)

34.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.4

/api/http/api_deployments_releases.go

// Copyright 2023 Northern.tech AS
//
//        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 http

import (
        "encoding/json"
        "net/http"
        "strconv"

        "github.com/ant0ine/go-json-rest/rest"
        "github.com/pkg/errors"

        "github.com/mendersoftware/go-lib-micro/log"
        "github.com/mendersoftware/go-lib-micro/requestlog"
        "github.com/mendersoftware/go-lib-micro/rest_utils"

        "github.com/mendersoftware/deployments/app"
        "github.com/mendersoftware/deployments/model"
)

func redactReleaseName(r *rest.Request) {
        q := r.URL.Query()
        if q.Get(ParamName) != "" {
                q.Set(ParamName, Redacted)
                r.URL.RawQuery = q.Encode()
        }
}

func (d *DeploymentsApiHandlers) GetReleases(w rest.ResponseWriter, r *rest.Request) {
        l := requestlog.GetRequestLogger(r)

        defer redactReleaseName(r)
        filter := getReleaseOrImageFilter(r, false)
        releases, _, err := d.store.GetReleases(r.Context(), filter)
        if err != nil {
                d.view.RenderInternalError(w, r, err, l)
                return
        }

        d.view.RenderSuccessGet(w, releases)
}

func (d *DeploymentsApiHandlers) ListReleases(w rest.ResponseWriter, r *rest.Request) {
        l := requestlog.GetRequestLogger(r)

        defer redactReleaseName(r)
        filter := getReleaseOrImageFilter(r, true)
        releases, totalCount, err := d.store.GetReleases(r.Context(), filter)
        if err != nil {
                d.view.RenderInternalError(w, r, err, l)
                return
        }

        hasNext := totalCount > int(filter.Page*filter.PerPage)
        links := rest_utils.MakePageLinkHdrs(r, uint64(filter.Page), uint64(filter.PerPage), hasNext)
        for _, l := range links {
                w.Header().Add("Link", l)
        }
        w.Header().Add(hdrTotalCount, strconv.Itoa(totalCount))

        d.view.RenderSuccessGet(w, releases)
}

func (d *DeploymentsApiHandlers) PatchRelease(w rest.ResponseWriter, r *rest.Request) {
        ctx := r.Context()
        l := log.FromContext(ctx)

        releaseName := r.PathParam(ParamName)
        if releaseName == "" {
                err := errors.New("path parameter 'release_name' cannot be empty")
                rest_utils.RestErrWithLog(w, r, l, err, http.StatusNotFound)
                return
        }

        var release model.ReleasePatch
        dec := json.NewDecoder(r.Body)
        if err := dec.Decode(&release); err != nil {
                rest_utils.RestErrWithLog(w, r, l,
                        errors.WithMessage(err,
                                "malformed JSON in request body"),
                        http.StatusBadRequest)
                return
        }
        if err := release.Validate(); err != nil {
                rest_utils.RestErrWithLog(w, r, l,
                        errors.WithMessage(err,
                                "invalid request body"),
                        http.StatusBadRequest)
                return
        }

        err := d.app.UpdateRelease(ctx, releaseName, release)
        if err != nil {
                status := http.StatusInternalServerError
                if errors.Is(err, app.ErrReleaseNotFound) {
                        status = http.StatusNotFound
                } else if errors.Is(err, model.ErrTooManyUniqueTags) {
                        status = http.StatusConflict
                }
                rest_utils.RestErrWithLog(w, r, l, err, status)
                return
        }

        w.WriteHeader(http.StatusNoContent)
}

func (d *DeploymentsApiHandlers) PutReleaseTags(
        w rest.ResponseWriter,
        r *rest.Request,
) {
        ctx := r.Context()
        l := log.FromContext(ctx)

        releaseName := r.PathParam(ParamName)
        if releaseName == "" {
                err := errors.New("path parameter 'release_name' cannot be empty")
                rest_utils.RestErrWithLog(w, r, l, err, http.StatusNotFound)
                return
        }

        var tags model.Tags
        dec := json.NewDecoder(r.Body)
        if err := dec.Decode(&tags); err != nil {
                rest_utils.RestErrWithLog(w, r, l,
                        errors.WithMessage(err,
                                "malformed JSON in request body"),
                        http.StatusBadRequest)
                return
        }
        if err := tags.Validate(); err != nil {
                rest_utils.RestErrWithLog(w, r, l,
                        errors.WithMessage(err,
                                "invalid request body"),
                        http.StatusBadRequest)
                return
        }

        err := d.app.ReplaceReleaseTags(ctx, releaseName, tags)
        if err != nil {
                status := http.StatusInternalServerError
                if errors.Is(err, app.ErrReleaseNotFound) {
                        status = http.StatusNotFound
                } else if errors.Is(err, model.ErrTooManyUniqueTags) {
                        status = http.StatusConflict
                }
                rest_utils.RestErrWithLog(w, r, l, err, status)
                return
        }

        w.WriteHeader(http.StatusNoContent)
}

func (d *DeploymentsApiHandlers) GetReleaseTagKeys(
        w rest.ResponseWriter,
        r *rest.Request,
) {
        ctx := r.Context()
        l := log.FromContext(ctx)

        tags, err := d.app.ListReleaseTags(ctx)
        if err != nil {
                rest_utils.RestErrWithLog(w, r, l, err, http.StatusInternalServerError)
                return
        }

        w.WriteHeader(http.StatusOK)
        err = w.WriteJson(tags)
        if err != nil {
                l.Errorf("failed to serialize JSON response: %s", err.Error())
        }
}

func (d *DeploymentsApiHandlers) GetReleasesUpdateTypes(
        w rest.ResponseWriter,
        r *rest.Request,
) {
        ctx := r.Context()
        l := log.FromContext(ctx)

        updateTypes, err := d.store.GetUpdateTypes(ctx)
        if err != nil {
                rest_utils.RestErrWithLog(w, r, l, err, http.StatusInternalServerError)
                return
        }

        w.WriteHeader(http.StatusOK)
        err = w.WriteJson(updateTypes)
        if err != nil {
                l.Errorf("failed to serialize JSON response: %s", err.Error())
        }
}

1	// Copyright 2023 Northern.tech AS
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package http
16
17	import (
18	"encoding/json"
19	"net/http"
20	"strconv"
21
22	"github.com/ant0ine/go-json-rest/rest"
23	"github.com/pkg/errors"
24
25	"github.com/mendersoftware/go-lib-micro/log"
26	"github.com/mendersoftware/go-lib-micro/requestlog"
27	"github.com/mendersoftware/go-lib-micro/rest_utils"
28
29	"github.com/mendersoftware/deployments/app"
30	"github.com/mendersoftware/deployments/model"
31	)
32
33	func redactReleaseName(r *rest.Request) {	17✔
34	q := r.URL.Query()	17✔
35	if q.Get(ParamName) != "" {	22✔
36	q.Set(ParamName, Redacted)	5✔
37	r.URL.RawQuery = q.Encode()	5✔
38	}	5✔
39	}
40
41	func (d DeploymentsApiHandlers) GetReleases(w rest.ResponseWriter, r rest.Request) {	5✔
42	l := requestlog.GetRequestLogger(r)	5✔
43		5✔
44	defer redactReleaseName(r)	5✔
45	filter := getReleaseOrImageFilter(r, false)	5✔
46	releases, _, err := d.store.GetReleases(r.Context(), filter)	5✔
47	if err != nil {	6✔
48	d.view.RenderInternalError(w, r, err, l)	1✔
49	return	1✔
50	}	1✔
51
52	d.view.RenderSuccessGet(w, releases)	4✔
53	}
54
55	func (d DeploymentsApiHandlers) ListReleases(w rest.ResponseWriter, r rest.Request) {	4✔
56	l := requestlog.GetRequestLogger(r)	4✔
57		4✔
58	defer redactReleaseName(r)	4✔
59	filter := getReleaseOrImageFilter(r, true)	4✔
60	releases, totalCount, err := d.store.GetReleases(r.Context(), filter)	4✔
61	if err != nil {	5✔
62	d.view.RenderInternalError(w, r, err, l)	1✔
63	return	1✔
64	}	1✔
65
66	hasNext := totalCount > int(filter.Page*filter.PerPage)	3✔
67	links := rest_utils.MakePageLinkHdrs(r, uint64(filter.Page), uint64(filter.PerPage), hasNext)	3✔
68	for _, l := range links {	6✔
69	w.Header().Add("Link", l)	3✔
70	}	3✔
71	w.Header().Add(hdrTotalCount, strconv.Itoa(totalCount))	3✔
72		3✔
73	d.view.RenderSuccessGet(w, releases)	3✔
74	}
75
76	func (d DeploymentsApiHandlers) PatchRelease(w rest.ResponseWriter, r rest.Request) {	4✔
77	ctx := r.Context()	4✔
78	l := log.FromContext(ctx)	4✔
79		4✔
80	releaseName := r.PathParam(ParamName)	4✔
81	if releaseName == "" {	4✔
82	err := errors.New("path parameter 'release_name' cannot be empty")	×
83	rest_utils.RestErrWithLog(w, r, l, err, http.StatusNotFound)	×
84	return	×
85	}	×
86
87	var release model.ReleasePatch	4✔
88	dec := json.NewDecoder(r.Body)	4✔
89	if err := dec.Decode(&release); err != nil {	4✔
90	rest_utils.RestErrWithLog(w, r, l,	×
91	errors.WithMessage(err,	×
92	"malformed JSON in request body"),	×
93	http.StatusBadRequest)	×
94	return	×
95	}	×
96	if err := release.Validate(); err != nil {	5✔
97	rest_utils.RestErrWithLog(w, r, l,	1✔
98	errors.WithMessage(err,	1✔
99	"invalid request body"),	1✔
100	http.StatusBadRequest)	1✔
101	return	1✔
102	}	1✔
103
104	err := d.app.UpdateRelease(ctx, releaseName, release)	3✔
105	if err != nil {	4✔
106	status := http.StatusInternalServerError	1✔
107	if errors.Is(err, app.ErrReleaseNotFound) {	1✔
108	status = http.StatusNotFound	×
109	} else if errors.Is(err, model.ErrTooManyUniqueTags) {	1✔
110	status = http.StatusConflict	×
111	}	×
112	rest_utils.RestErrWithLog(w, r, l, err, status)	1✔
113	return	1✔
114	}
115
116	w.WriteHeader(http.StatusNoContent)	2✔
117	}
118
119	func (d *DeploymentsApiHandlers) PutReleaseTags(
120	w rest.ResponseWriter,
121	r *rest.Request,
122	) {	8✔
123	ctx := r.Context()	8✔
124	l := log.FromContext(ctx)	8✔
125		8✔
126	releaseName := r.PathParam(ParamName)	8✔
127	if releaseName == "" {	9✔
128	err := errors.New("path parameter 'release_name' cannot be empty")	1✔
129	rest_utils.RestErrWithLog(w, r, l, err, http.StatusNotFound)	1✔
130	return	1✔
131	}	1✔
132
133	var tags model.Tags	7✔
134	dec := json.NewDecoder(r.Body)	7✔
135	if err := dec.Decode(&tags); err != nil {	8✔
136	rest_utils.RestErrWithLog(w, r, l,	1✔
137	errors.WithMessage(err,	1✔
138	"malformed JSON in request body"),	1✔
139	http.StatusBadRequest)	1✔
140	return	1✔
141	}	1✔
142	if err := tags.Validate(); err != nil {	7✔
143	rest_utils.RestErrWithLog(w, r, l,	1✔
144	errors.WithMessage(err,	1✔
145	"invalid request body"),	1✔
146	http.StatusBadRequest)	1✔
147	return	1✔
148	}	1✔
149
150	err := d.app.ReplaceReleaseTags(ctx, releaseName, tags)	5✔
151	if err != nil {	8✔
152	status := http.StatusInternalServerError	3✔
153	if errors.Is(err, app.ErrReleaseNotFound) {	4✔
154	status = http.StatusNotFound	1✔
155	} else if errors.Is(err, model.ErrTooManyUniqueTags) {	4✔
156	status = http.StatusConflict	1✔
157	}	1✔
158	rest_utils.RestErrWithLog(w, r, l, err, status)	3✔
159	return	3✔
160	}
161
162	w.WriteHeader(http.StatusNoContent)	2✔
163	}
164
165	func (d *DeploymentsApiHandlers) GetReleaseTagKeys(
166	w rest.ResponseWriter,
167	r *rest.Request,
168	) {	3✔
169	ctx := r.Context()	3✔
170	l := log.FromContext(ctx)	3✔
171		3✔
172	tags, err := d.app.ListReleaseTags(ctx)	3✔
173	if err != nil {	5✔
174	rest_utils.RestErrWithLog(w, r, l, err, http.StatusInternalServerError)	2✔
175	return	2✔
176	}	2✔
177
178	w.WriteHeader(http.StatusOK)	1✔
179	err = w.WriteJson(tags)	1✔
180	if err != nil {	1✔
181	l.Errorf("failed to serialize JSON response: %s", err.Error())	×
182	}	×
183	}
184
185	func (d *DeploymentsApiHandlers) GetReleasesUpdateTypes(
186	w rest.ResponseWriter,
187	r *rest.Request,
188	) {	1✔
189	ctx := r.Context()	1✔
190	l := log.FromContext(ctx)	1✔
191		1✔
192	updateTypes, err := d.store.GetUpdateTypes(ctx)	1✔
193	if err != nil {	1✔
NEW 194	rest_utils.RestErrWithLog(w, r, l, err, http.StatusInternalServerError)	×
NEW 195	return	×
NEW 196	}	×
197
198	w.WriteHeader(http.StatusOK)	1✔
199	err = w.WriteJson(updateTypes)	1✔
200	if err != nil {	1✔
NEW 201	l.Errorf("failed to serialize JSON response: %s", err.Error())	×
NEW 202	}	×
203	}

mendersoftware / deployments / 972678690

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous