gitea

1
// Copyright 2019 The Gitea Authors. All rights reserved.
2
// Copyright 2018 Jonas Franz. All rights reserved.
3
// SPDX-License-Identifier: MIT
4

5
package migrations
6

7
import (
8
	"testing"
9
	"time"
10

11
	"code.gitea.io/gitea/models/unittest"
12
	base "code.gitea.io/gitea/modules/migration"
13

14
	"github.com/stretchr/testify/assert"
15
)
16

17
func TestMain(m *testing.M) {
18
	unittest.MainTest(m)
19
}
20

21
func timePtr(t time.Time) *time.Time {
22
	return &t
23
}
24

25
func assertTimeEqual(t *testing.T, expected, actual time.Time) {
26
	assert.Equal(t, expected.UTC(), actual.UTC())
27
}
28

29
func assertTimePtrEqual(t *testing.T, expected, actual *time.Time) {
30
	if expected == nil {
31
		assert.Nil(t, actual)
32
	} else {
33
		assert.NotNil(t, actual)
34
		assertTimeEqual(t, *expected, *actual)
35
	}
36
}
37

38
func assertCommentEqual(t *testing.T, expected, actual *base.Comment) {
39
	assert.Equal(t, expected.IssueIndex, actual.IssueIndex)
40
	assert.Equal(t, expected.PosterID, actual.PosterID)
41
	assert.Equal(t, expected.PosterName, actual.PosterName)
42
	assert.Equal(t, expected.PosterEmail, actual.PosterEmail)
43
	assertTimeEqual(t, expected.Created, actual.Created)
44
	assertTimeEqual(t, expected.Updated, actual.Updated)
45
	assert.Equal(t, expected.Content, actual.Content)
46
	assertReactionsEqual(t, expected.Reactions, actual.Reactions)
47
}
48

49
func assertCommentsEqual(t *testing.T, expected, actual []*base.Comment) {
50
	if assert.Len(t, actual, len(expected)) {
51
		for i := range expected {
52
			assertCommentEqual(t, expected[i], actual[i])
53
		}
54
	}
55
}
56

57
func assertLabelEqual(t *testing.T, expected, actual *base.Label) {
58
	assert.Equal(t, expected.Name, actual.Name)
59
	assert.Equal(t, expected.Exclusive, actual.Exclusive)
60
	assert.Equal(t, expected.Color, actual.Color)
61
	assert.Equal(t, expected.Description, actual.Description)
62
}
63

64
func assertLabelsEqual(t *testing.T, expected, actual []*base.Label) {
65
	if assert.Len(t, actual, len(expected)) {
66
		for i := range expected {
67
			assertLabelEqual(t, expected[i], actual[i])
68
		}
69
	}
70
}
71

72
func assertMilestoneEqual(t *testing.T, expected, actual *base.Milestone) {
73
	assert.Equal(t, expected.Title, actual.Title)
74
	assert.Equal(t, expected.Description, actual.Description)
75
	assertTimePtrEqual(t, expected.Deadline, actual.Deadline)
76
	assertTimeEqual(t, expected.Created, actual.Created)
77
	assertTimePtrEqual(t, expected.Updated, actual.Updated)
78
	assertTimePtrEqual(t, expected.Closed, actual.Closed)
79
	assert.Equal(t, expected.State, actual.State)
80
}
81

82
func assertMilestonesEqual(t *testing.T, expected, actual []*base.Milestone) {
83
	if assert.Len(t, actual, len(expected)) {
84
		for i := range expected {
85
			assertMilestoneEqual(t, expected[i], actual[i])
86
		}
87
	}
88
}
89

90
func assertIssueEqual(t *testing.T, expected, actual *base.Issue) {
91
	assert.Equal(t, expected.Number, actual.Number)
92
	assert.Equal(t, expected.PosterID, actual.PosterID)
93
	assert.Equal(t, expected.PosterName, actual.PosterName)
94
	assert.Equal(t, expected.PosterEmail, actual.PosterEmail)
95
	assert.Equal(t, expected.Title, actual.Title)
96
	assert.Equal(t, expected.Content, actual.Content)
97
	assert.Equal(t, expected.Ref, actual.Ref)
98
	assert.Equal(t, expected.Milestone, actual.Milestone)
99
	assert.Equal(t, expected.State, actual.State)
100
	assert.Equal(t, expected.IsLocked, actual.IsLocked)
101
	assertTimeEqual(t, expected.Created, actual.Created)
102
	assertTimeEqual(t, expected.Updated, actual.Updated)
103
	assertTimePtrEqual(t, expected.Closed, actual.Closed)
104
	assertLabelsEqual(t, expected.Labels, actual.Labels)
105
	assertReactionsEqual(t, expected.Reactions, actual.Reactions)
106
	assert.ElementsMatch(t, expected.Assignees, actual.Assignees)
107
}
108

109
func assertIssuesEqual(t *testing.T, expected, actual []*base.Issue) {
110
	if assert.Len(t, actual, len(expected)) {
111
		for i := range expected {
112
			assertIssueEqual(t, expected[i], actual[i])
113
		}
114
	}
115
}
116

117
func assertPullRequestEqual(t *testing.T, expected, actual *base.PullRequest) {
118
	assert.Equal(t, expected.Number, actual.Number)
119
	assert.Equal(t, expected.Title, actual.Title)
120
	assert.Equal(t, expected.PosterID, actual.PosterID)
121
	assert.Equal(t, expected.PosterName, actual.PosterName)
122
	assert.Equal(t, expected.PosterEmail, actual.PosterEmail)
123
	assert.Equal(t, expected.Content, actual.Content)
124
	assert.Equal(t, expected.Milestone, actual.Milestone)
125
	assert.Equal(t, expected.State, actual.State)
126
	assertTimeEqual(t, expected.Created, actual.Created)
127
	assertTimeEqual(t, expected.Updated, actual.Updated)
128
	assertTimePtrEqual(t, expected.Closed, actual.Closed)
129
	assertLabelsEqual(t, expected.Labels, actual.Labels)
130
	assert.Equal(t, expected.PatchURL, actual.PatchURL)
131
	assert.Equal(t, expected.Merged, actual.Merged)
132
	assertTimePtrEqual(t, expected.MergedTime, actual.MergedTime)
133
	assert.Equal(t, expected.MergeCommitSHA, actual.MergeCommitSHA)
134
	assertPullRequestBranchEqual(t, expected.Head, actual.Head)
135
	assertPullRequestBranchEqual(t, expected.Base, actual.Base)
136
	assert.ElementsMatch(t, expected.Assignees, actual.Assignees)
137
	assert.Equal(t, expected.IsLocked, actual.IsLocked)
138
	assertReactionsEqual(t, expected.Reactions, actual.Reactions)
139
}
140

141
func assertPullRequestsEqual(t *testing.T, expected, actual []*base.PullRequest) {
142
	if assert.Len(t, actual, len(expected)) {
143
		for i := range expected {
144
			assertPullRequestEqual(t, expected[i], actual[i])
145
		}
146
	}
147
}
148

149
func assertPullRequestBranchEqual(t *testing.T, expected, actual base.PullRequestBranch) {
150
	assert.Equal(t, expected.CloneURL, actual.CloneURL)
151
	assert.Equal(t, expected.Ref, actual.Ref)
152
	assert.Equal(t, expected.SHA, actual.SHA)
153
	assert.Equal(t, expected.RepoName, actual.RepoName)
154
	assert.Equal(t, expected.OwnerName, actual.OwnerName)
155
}
156

157
func assertReactionEqual(t *testing.T, expected, actual *base.Reaction) {
158
	assert.Equal(t, expected.UserID, actual.UserID)
159
	assert.Equal(t, expected.UserName, actual.UserName)
160
	assert.Equal(t, expected.Content, actual.Content)
161
}
162

163
func assertReactionsEqual(t *testing.T, expected, actual []*base.Reaction) {
164
	if assert.Len(t, actual, len(expected)) {
165
		for i := range expected {
166
			assertReactionEqual(t, expected[i], actual[i])
167
		}
168
	}
169
}
170

171
func assertReleaseAssetEqual(t *testing.T, expected, actual *base.ReleaseAsset) {
172
	assert.Equal(t, expected.ID, actual.ID)
173
	assert.Equal(t, expected.Name, actual.Name)
174
	assert.Equal(t, expected.ContentType, actual.ContentType)
175
	assert.Equal(t, expected.Size, actual.Size)
176
	assert.Equal(t, expected.DownloadCount, actual.DownloadCount)
177
	assertTimeEqual(t, expected.Created, actual.Created)
178
	assertTimeEqual(t, expected.Updated, actual.Updated)
179
	assert.Equal(t, expected.DownloadURL, actual.DownloadURL)
180
}
181

182
func assertReleaseAssetsEqual(t *testing.T, expected, actual []*base.ReleaseAsset) {
183
	if assert.Len(t, actual, len(expected)) {
184
		for i := range expected {
185
			assertReleaseAssetEqual(t, expected[i], actual[i])
186
		}
187
	}
188
}
189

190
func assertReleaseEqual(t *testing.T, expected, actual *base.Release) {
191
	assert.Equal(t, expected.TagName, actual.TagName)
192
	assert.Equal(t, expected.TargetCommitish, actual.TargetCommitish)
193
	assert.Equal(t, expected.Name, actual.Name)
194
	assert.Equal(t, expected.Body, actual.Body)
195
	assert.Equal(t, expected.Draft, actual.Draft)
196
	assert.Equal(t, expected.Prerelease, actual.Prerelease)
197
	assert.Equal(t, expected.PublisherID, actual.PublisherID)
198
	assert.Equal(t, expected.PublisherName, actual.PublisherName)
199
	assert.Equal(t, expected.PublisherEmail, actual.PublisherEmail)
200
	assertReleaseAssetsEqual(t, expected.Assets, actual.Assets)
201
	assertTimeEqual(t, expected.Created, actual.Created)
202
	assertTimeEqual(t, expected.Published, actual.Published)
203
}
204

205
func assertReleasesEqual(t *testing.T, expected, actual []*base.Release) {
206
	if assert.Len(t, actual, len(expected)) {
207
		for i := range expected {
208
			assertReleaseEqual(t, expected[i], actual[i])
209
		}
210
	}
211
}
212

213
func assertRepositoryEqual(t *testing.T, expected, actual *base.Repository) {
214
	assert.Equal(t, expected.Name, actual.Name)
215
	assert.Equal(t, expected.Owner, actual.Owner)
216
	assert.Equal(t, expected.IsPrivate, actual.IsPrivate)
217
	assert.Equal(t, expected.IsMirror, actual.IsMirror)
218
	assert.Equal(t, expected.Description, actual.Description)
219
	assert.Equal(t, expected.CloneURL, actual.CloneURL)
220
	assert.Equal(t, expected.OriginalURL, actual.OriginalURL)
221
	assert.Equal(t, expected.DefaultBranch, actual.DefaultBranch)
222
}
223

224
func assertReviewEqual(t *testing.T, expected, actual *base.Review) {
225
	assert.Equal(t, expected.ID, actual.ID, "ID")
226
	assert.Equal(t, expected.IssueIndex, actual.IssueIndex, "IsssueIndex")
227
	assert.Equal(t, expected.ReviewerID, actual.ReviewerID, "ReviewerID")
228
	assert.Equal(t, expected.ReviewerName, actual.ReviewerName, "ReviewerName")
229
	assert.Equal(t, expected.Official, actual.Official, "Official")
230
	assert.Equal(t, expected.CommitID, actual.CommitID, "CommitID")
231
	assert.Equal(t, expected.Content, actual.Content, "Content")
232
	assert.WithinDuration(t, expected.CreatedAt, actual.CreatedAt, 10*time.Second)
233
	assert.Equal(t, expected.State, actual.State, "State")
234
	assertReviewCommentsEqual(t, expected.Comments, actual.Comments)
235
}
236

237
func assertReviewsEqual(t *testing.T, expected, actual []*base.Review) {
238
	if assert.Len(t, actual, len(expected)) {
239
		for i := range expected {
240
			assertReviewEqual(t, expected[i], actual[i])
241
		}
242
	}
243
}
244

245
func assertReviewCommentEqual(t *testing.T, expected, actual *base.ReviewComment) {
246
	assert.Equal(t, expected.ID, actual.ID)
247
	assert.Equal(t, expected.InReplyTo, actual.InReplyTo)
248
	assert.Equal(t, expected.Content, actual.Content)
249
	assert.Equal(t, expected.TreePath, actual.TreePath)
250
	assert.Equal(t, expected.DiffHunk, actual.DiffHunk)
251
	assert.Equal(t, expected.Position, actual.Position)
252
	assert.Equal(t, expected.Line, actual.Line)
253
	assert.Equal(t, expected.CommitID, actual.CommitID)
254
	assert.Equal(t, expected.PosterID, actual.PosterID)
255
	assertReactionsEqual(t, expected.Reactions, actual.Reactions)
256
	assertTimeEqual(t, expected.CreatedAt, actual.CreatedAt)
257
	assertTimeEqual(t, expected.UpdatedAt, actual.UpdatedAt)
258
}
259

260
func assertReviewCommentsEqual(t *testing.T, expected, actual []*base.ReviewComment) {
261
	if assert.Len(t, actual, len(expected)) {
262
		for i := range expected {
263
			assertReviewCommentEqual(t, expected[i], actual[i])
264
		}
265
	}
266
}
267