-
Notifications
You must be signed in to change notification settings - Fork 28
/
Copy pathpublic_repositories_test.go
227 lines (186 loc) · 8.64 KB
/
public_repositories_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
package handler
import (
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"testing"
"github.com/content-services/content-sources-backend/pkg/api"
"github.com/content-services/content-sources-backend/pkg/config"
"github.com/content-services/content-sources-backend/pkg/dao"
ce "github.com/content-services/content-sources-backend/pkg/errors"
"github.com/content-services/content-sources-backend/pkg/middleware"
"github.com/content-services/content-sources-backend/pkg/test"
test_handler "github.com/content-services/content-sources-backend/pkg/test/handler"
"github.com/labstack/echo/v4"
echo_middleware "github.com/labstack/echo/v4/middleware"
"github.com/redhatinsights/platform-go-middlewares/v2/identity"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
type PublicReposSuite struct {
suite.Suite
reg *dao.MockDaoRegistry
}
func TestPublicReposSuite(t *testing.T) {
suite.Run(t, new(PublicReposSuite))
}
func (suite *PublicReposSuite) SetupTest() {
suite.reg = dao.GetMockDaoRegistry(suite.T())
}
func (suite *PublicReposSuite) serveRepositoriesRouter(req *http.Request) (int, []byte, error) {
router := echo.New()
router.Use(echo_middleware.RequestIDWithConfig(echo_middleware.RequestIDConfig{
TargetHeader: "x-rh-insights-request-id",
}))
router.Use(middleware.WrapMiddlewareWithSkipper(identity.EnforceIdentity, middleware.SkipMiddleware))
router.HTTPErrorHandler = config.CustomHTTPErrorHandler
pathPrefix := router.Group(api.FullRootPath())
RegisterPublicRepositoriesRoutes(pathPrefix, suite.reg.ToDaoRegistry())
rr := httptest.NewRecorder()
router.ServeHTTP(rr, req)
response := rr.Result()
defer response.Body.Close()
body, err := io.ReadAll(response.Body)
return response.StatusCode, body, err
}
func (suite *PublicReposSuite) TestList() {
t := suite.T()
collection := createPublicRepoCollection(1, 10, 0)
paginationData := api.PaginationData{Limit: 10, Offset: DefaultOffset}
suite.reg.Repository.On("ListPublic", test.MockCtx(), paginationData, api.FilterData{}).Return(collection, int64(1), nil)
path := fmt.Sprintf("%s/public_repositories/?limit=%d", api.FullRootPath(), 10)
req := httptest.NewRequest(http.MethodGet, path, nil)
req.Header.Set(api.IdentityHeader, test_handler.EncodedIdentity(t))
code, body, err := suite.serveRepositoriesRouter(req)
assert.Nil(t, err)
response := api.PublicRepositoryCollectionResponse{}
err = json.Unmarshal(body, &response)
assert.Nil(t, err)
assert.Equal(t, http.StatusOK, code)
assert.Equal(t, 0, response.Meta.Offset)
assert.Equal(t, int64(1), response.Meta.Count)
assert.Equal(t, 10, response.Meta.Limit)
assert.Equal(t, 1, len(response.Data))
assert.Equal(t, collection.Data[0].URL, response.Data[0].URL)
assert.Equal(t, collection.Data[0].LastIntrospectionUpdateTime, response.Data[0].LastIntrospectionUpdateTime)
assert.Equal(t, collection.Data[0].LastIntrospectionTime, response.Data[0].LastIntrospectionTime)
assert.Equal(t, collection.Data[0].LastIntrospectionSuccessTime, response.Data[0].LastIntrospectionSuccessTime)
assert.Equal(t, collection.Data[0].LastIntrospectionError, response.Data[0].LastIntrospectionError)
}
func (suite *PublicReposSuite) TestListNoRepositories() {
t := suite.T()
collection := api.PublicRepositoryCollectionResponse{}
paginationData := api.PaginationData{Limit: DefaultLimit, Offset: DefaultOffset}
suite.reg.Repository.On("ListPublic", test.MockCtx(), paginationData, api.FilterData{}).Return(collection, int64(0), nil)
req := httptest.NewRequest(http.MethodGet, api.FullRootPath()+"/public_repositories/", nil)
req.Header.Set(api.IdentityHeader, test_handler.EncodedIdentity(t))
code, body, err := suite.serveRepositoriesRouter(req)
assert.Nil(t, err)
assert.Equal(t, http.StatusOK, code)
response := api.RepositoryCollectionResponse{}
err = json.Unmarshal(body, &response)
assert.Nil(t, err)
assert.Equal(t, 0, response.Meta.Offset)
assert.Equal(t, int64(0), response.Meta.Count)
assert.Equal(t, 100, response.Meta.Limit)
assert.Equal(t, 0, len(response.Data))
assert.Equal(t, api.FullRootPath()+"/public_repositories/?limit=100&offset=0", response.Links.Last)
assert.Equal(t, api.FullRootPath()+"/public_repositories/?limit=100&offset=0", response.Links.First)
}
func (suite *PublicReposSuite) TestListPagedExtraRemaining() {
t := suite.T()
collection := api.PublicRepositoryCollectionResponse{}
paginationData1 := api.PaginationData{Limit: 10, Offset: 0}
paginationData2 := api.PaginationData{Limit: 10, Offset: 100}
suite.reg.Repository.On("ListPublic", test.MockCtx(), paginationData1, api.FilterData{}).Return(collection, int64(102), nil).Once()
suite.reg.Repository.On("ListPublic", test.MockCtx(), paginationData2, api.FilterData{}).Return(collection, int64(102), nil).Once()
path := fmt.Sprintf("%s/public_repositories/?limit=%d", api.FullRootPath(), 10)
req := httptest.NewRequest(http.MethodGet, path, nil)
req.Header.Set(api.IdentityHeader, test_handler.EncodedIdentity(t))
code, body, err := suite.serveRepositoriesRouter(req)
assert.Nil(t, err)
assert.Equal(t, http.StatusOK, code)
response := api.PublicRepositoryCollectionResponse{}
err = json.Unmarshal(body, &response)
assert.Nil(t, err)
assert.Equal(t, 0, response.Meta.Offset)
assert.Equal(t, 10, response.Meta.Limit)
assert.Equal(t, int64(102), response.Meta.Count)
assert.NotEmpty(t, response.Links.Last)
// Fetch last page
req = httptest.NewRequest(http.MethodGet, response.Links.Last, nil)
req.Header.Set(api.IdentityHeader, test_handler.EncodedIdentity(t))
code, body, err = suite.serveRepositoriesRouter(req)
assert.Nil(t, err)
assert.Equal(t, http.StatusOK, code)
response = api.PublicRepositoryCollectionResponse{}
err = json.Unmarshal(body, &response)
assert.Nil(t, err)
}
func (suite *PublicReposSuite) TestListPagedNoRemaining() {
t := suite.T()
paginationData1 := api.PaginationData{Limit: 10, Offset: 0}
paginationData2 := api.PaginationData{Limit: 10, Offset: 90}
collection := api.PublicRepositoryCollectionResponse{}
suite.reg.Repository.On("ListPublic", test.MockCtx(), paginationData1, api.FilterData{}).Return(collection, int64(100), nil)
suite.reg.Repository.On("ListPublic", test.MockCtx(), paginationData2, api.FilterData{}).Return(collection, int64(100), nil)
path := fmt.Sprintf("%s/public_repositories/?limit=%d", api.FullRootPath(), 10)
req := httptest.NewRequest(http.MethodGet, path, nil)
req.Header.Set(api.IdentityHeader, test_handler.EncodedIdentity(t))
code, body, err := suite.serveRepositoriesRouter(req)
assert.Nil(t, err)
assert.Equal(t, http.StatusOK, code)
response := api.PublicRepositoryCollectionResponse{}
err = json.Unmarshal(body, &response)
assert.Nil(t, err)
assert.Equal(t, 0, response.Meta.Offset)
assert.Equal(t, 10, response.Meta.Limit)
assert.Equal(t, int64(100), response.Meta.Count)
assert.NotEmpty(t, response.Links.Last)
// Fetch last page
req = httptest.NewRequest(http.MethodGet, response.Links.Last, nil)
req.Header.Set(api.IdentityHeader, test_handler.EncodedIdentity(t))
code, body, err = suite.serveRepositoriesRouter(req)
assert.Nil(t, err)
assert.Equal(t, http.StatusOK, code)
response = api.PublicRepositoryCollectionResponse{}
err = json.Unmarshal(body, &response)
assert.Nil(t, err)
}
func (suite *PublicReposSuite) TestListDaoError() {
t := suite.T()
daoError := ce.DaoError{
Message: "Column doesn't exist",
}
paginationData := api.PaginationData{Limit: DefaultLimit}
suite.reg.Repository.On("ListPublic", test.MockCtx(), paginationData, api.FilterData{}).
Return(api.PublicRepositoryCollectionResponse{}, int64(0), &daoError)
path := fmt.Sprintf("%s/public_repositories/", api.FullRootPath())
req := httptest.NewRequest(http.MethodGet, path, nil)
req.Header.Set(api.IdentityHeader, test_handler.EncodedIdentity(t))
code, _, err := suite.serveRepositoriesRouter(req)
assert.Nil(t, err)
assert.Equal(t, http.StatusInternalServerError, code)
}
func createPublicRepoCollection(size, limit, offset int) api.PublicRepositoryCollectionResponse {
repos := make([]api.PublicRepositoryResponse, size)
for i := 0; i < size; i++ {
repo := api.PublicRepositoryResponse{
URL: fmt.Sprintf("http://repo-%d.com", i),
LastIntrospectionTime: "2022-08-31 14:17:50.257623 -0400 EDT",
LastIntrospectionSuccessTime: "2022-08-31 14:17:50.257623 -0400 EDT",
LastIntrospectionUpdateTime: "2022-08-31 14:17:50.257623 -0400 EDT",
LastIntrospectionError: "",
Status: "Valid",
}
repos[i] = repo
}
collection := api.PublicRepositoryCollectionResponse{
Data: repos,
}
params := fmt.Sprintf("?offset=%d&limit=%d", offset, limit)
setCollectionResponseMetadata(&collection, getTestContext(params), int64(size))
return collection
}