Skip to content

Commit b9cf210

Browse files
per1234per1234
committed
Use most appropriate test assertion types
1 parent b7278c3 commit b9cf210

File tree

2 files changed

+50
-50
lines changed

2 files changed

+50
-50
lines changed

‎internal/result/result_test.go

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -297,12 +297,12 @@ func TestWriteReport(t *testing.T) {
297297
require.Nil(t, err)
298298

299299
flags.Set("report-file", reportFilePath.Join("report-file.json").String())
300-
assert.Nil(t, configuration.Initialize(flags, projectPaths))
300+
require.Nil(t, configuration.Initialize(flags, projectPaths))
301301
assert.Error(t, Results.WriteReport(), "Parent folder creation should fail due to a collision with an existing file at that path")
302302

303303
reportFilePath = reportFolderPath.Join("report-file-subfolder", "report-file-subsubfolder", "report-file.json")
304304
flags.Set("report-file", reportFilePath.String())
305-
assert.Nil(t, configuration.Initialize(flags, projectPaths))
305+
require.Nil(t, configuration.Initialize(flags, projectPaths))
306306
assert.NoError(t, Results.WriteReport(), "Creation of multiple levels of parent folders")
307307

308308
reportFile, err := reportFilePath.Open()

‎internal/rule/schema/schema_test.go

Lines changed: 48 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ import (
2323
"github.com/arduino/arduino-lint/internal/rule/schema/testdata"
2424
"github.com/arduino/go-properties-orderedmap"
2525
"github.com/ory/jsonschema/v3"
26-
"github.com/stretchr/testify/require"
26+
"github.com/stretchr/testify/assert"
2727
)
2828

2929
var validMap = map[string]string{
@@ -50,27 +50,27 @@ func init() {
5050
}
5151

5252
func TestCompile(t *testing.T) {
53-
require.Panics(t, func() {
53+
assert.Panics(t, func() {
5454
Compile("valid-schema-with-references.json", []string{"nonexistent.json"}, testdata.Asset)
5555
})
5656

57-
require.Panics(t, func() {
57+
assert.Panics(t, func() {
5858
Compile("valid-schema-with-references.json", []string{"schema-without-id.json"}, testdata.Asset)
5959
})
6060

61-
require.Panics(t, func() {
61+
assert.Panics(t, func() {
6262
Compile("invalid-schema.json", []string{}, testdata.Asset)
6363
})
6464

65-
require.Panics(t, func() {
65+
assert.Panics(t, func() {
6666
Compile("valid-schema-with-references.json", []string{}, testdata.Asset)
6767
})
6868

69-
require.NotPanics(t, func() {
69+
assert.NotPanics(t, func() {
7070
Compile("valid-schema.json", []string{}, testdata.Asset)
7171
})
7272

73-
require.NotPanics(t, func() {
73+
assert.NotPanics(t, func() {
7474
Compile(
7575
"valid-schema-with-references.json",
7676
[]string{
@@ -86,134 +86,134 @@ func TestValidate(t *testing.T) {
8686
schemaObject := Compile("valid-schema.json", []string{}, testdata.Asset)
8787
propertiesMap := properties.NewFromHashmap(validMap)
8888
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), schemaObject)
89-
require.Nil(t, validationResult.Result)
89+
assert.Nil(t, validationResult.Result)
9090

9191
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
92-
require.Nil(t, validationResult.Result)
92+
assert.Nil(t, validationResult.Result)
9393

9494
propertiesMap.Set("property1", "a")
9595
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), schemaObject)
96-
require.Equal(t, "#/property1", validationResult.Result.InstancePtr)
97-
require.Equal(t, "#/properties/property1/minLength", validationResult.Result.SchemaPtr)
96+
assert.Equal(t, "#/property1", validationResult.Result.InstancePtr)
97+
assert.Equal(t, "#/properties/property1/minLength", validationResult.Result.SchemaPtr)
9898
}
9999

100100
func TestRequiredPropertyMissing(t *testing.T) {
101101
propertiesMap := properties.NewFromHashmap(validMap)
102102
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
103-
require.False(t, RequiredPropertyMissing("property1", validationResult))
103+
assert.False(t, RequiredPropertyMissing("property1", validationResult))
104104

105105
propertiesMap.Remove("property1")
106106
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
107-
require.True(t, RequiredPropertyMissing("property1", validationResult))
107+
assert.True(t, RequiredPropertyMissing("property1", validationResult))
108108
}
109109

110110
func TestPropertyPatternMismatch(t *testing.T) {
111111
propertiesMap := properties.NewFromHashmap(validMap)
112112
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
113-
require.False(t, PropertyPatternMismatch("property2", validationResult))
113+
assert.False(t, PropertyPatternMismatch("property2", validationResult))
114114

115115
propertiesMap.Set("property2", "fOo")
116116
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
117-
require.True(t, PropertyPatternMismatch("property2", validationResult))
117+
assert.True(t, PropertyPatternMismatch("property2", validationResult))
118118

119-
require.False(t, PropertyPatternMismatch("property1", validationResult))
119+
assert.False(t, PropertyPatternMismatch("property1", validationResult))
120120
}
121121

122122
func TestPropertyLessThanMinLength(t *testing.T) {
123123
propertiesMap := properties.NewFromHashmap(validMap)
124124
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
125-
require.False(t, PropertyLessThanMinLength("property1", validationResult))
125+
assert.False(t, PropertyLessThanMinLength("property1", validationResult))
126126

127127
propertiesMap.Set("property1", "a")
128128
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
129-
require.True(t, PropertyLessThanMinLength("property1", validationResult))
129+
assert.True(t, PropertyLessThanMinLength("property1", validationResult))
130130
}
131131

132132
func TestPropertyGreaterThanMaxLength(t *testing.T) {
133133
propertiesMap := properties.NewFromHashmap(validMap)
134134
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
135-
require.False(t, PropertyGreaterThanMaxLength("property1", validationResult))
135+
assert.False(t, PropertyGreaterThanMaxLength("property1", validationResult))
136136

137137
propertiesMap.Set("property1", "12345")
138138
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
139-
require.True(t, PropertyGreaterThanMaxLength("property1", validationResult))
139+
assert.True(t, PropertyGreaterThanMaxLength("property1", validationResult))
140140
}
141141

142142
func TestPropertyEnumMismatch(t *testing.T) {
143143
propertiesMap := properties.NewFromHashmap(validMap)
144144
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
145-
require.False(t, PropertyEnumMismatch("property3", validationResult))
145+
assert.False(t, PropertyEnumMismatch("property3", validationResult))
146146

147147
propertiesMap.Set("property3", "invalid")
148148
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
149-
require.True(t, PropertyEnumMismatch("property3", validationResult))
149+
assert.True(t, PropertyEnumMismatch("property3", validationResult))
150150
}
151151

152152
func TestPropertyDependenciesMissing(t *testing.T) {
153153
propertiesMap := properties.NewFromHashmap(validMap)
154154
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
155-
require.False(t, PropertyDependenciesMissing("dependentProperty", validationResult))
155+
assert.False(t, PropertyDependenciesMissing("dependentProperty", validationResult))
156156

157157
propertiesMap.Remove("dependencyProperty")
158158
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
159-
require.True(t, PropertyDependenciesMissing("dependentProperty", validationResult))
159+
assert.True(t, PropertyDependenciesMissing("dependentProperty", validationResult))
160160
}
161161

162162
func TestMisspelledOptionalPropertyFound(t *testing.T) {
163163
propertiesMap := properties.NewFromHashmap(validMap)
164164
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
165-
require.False(t, MisspelledOptionalPropertyFound(validationResult))
165+
assert.False(t, MisspelledOptionalPropertyFound(validationResult))
166166

167167
propertiesMap.Set("porperties", "foo")
168168
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
169-
require.True(t, MisspelledOptionalPropertyFound(validationResult))
169+
assert.True(t, MisspelledOptionalPropertyFound(validationResult))
170170
}
171171

172172
func TestValidationErrorMatch(t *testing.T) {
173173
propertiesMap := properties.NewFromHashmap(validMap)
174174
validationResult := Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
175-
require.False(t, ValidationErrorMatch("", "", "", "", validationResult))
175+
assert.False(t, ValidationErrorMatch("", "", "", "", validationResult))
176176

177177
propertiesMap.Set("property2", "fOo")
178178
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
179-
require.False(t, ValidationErrorMatch("nomatch", "nomatch", "nomatch", "nomatch", validationResult))
180-
require.False(t, ValidationErrorMatch("^#/property2$", "nomatch", "nomatch", "nomatch", validationResult))
181-
require.False(t, ValidationErrorMatch("^#/property2$", "/pattern$", "nomatch", "nomatch", validationResult))
182-
require.False(t, ValidationErrorMatch("^#/property2$", "/pattern$", `^\^\[a-z\]\+\$$`, "nomatch", validationResult))
183-
require.True(t, ValidationErrorMatch("^#/property2$", "/pattern$", `^"\^\[a-z\]\+\$"$`, "", validationResult))
184-
require.True(t, ValidationErrorMatch("", "", "", "", validationResult))
179+
assert.False(t, ValidationErrorMatch("nomatch", "nomatch", "nomatch", "nomatch", validationResult))
180+
assert.False(t, ValidationErrorMatch("^#/property2$", "nomatch", "nomatch", "nomatch", validationResult))
181+
assert.False(t, ValidationErrorMatch("^#/property2$", "/pattern$", "nomatch", "nomatch", validationResult))
182+
assert.False(t, ValidationErrorMatch("^#/property2$", "/pattern$", `^\^\[a-z\]\+\$$`, "nomatch", validationResult))
183+
assert.True(t, ValidationErrorMatch("^#/property2$", "/pattern$", `^"\^\[a-z\]\+\$"$`, "", validationResult))
184+
assert.True(t, ValidationErrorMatch("", "", "", "", validationResult))
185185

186186
propertiesMap.Set("property3", "bAz")
187187
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
188-
require.True(t, ValidationErrorMatch("^#/property3$", "/pattern$", "", "", validationResult), "Match pointer below logic inversion keyword")
188+
assert.True(t, ValidationErrorMatch("^#/property3$", "/pattern$", "", "", validationResult), "Match pointer below logic inversion keyword")
189189

190190
propertiesMap = properties.NewFromHashmap(validMap)
191191
propertiesMap.Remove("property1")
192192
validationResult = Validate(general.PropertiesToMap(propertiesMap, 0), validSchemaWithReferences)
193-
require.False(t, ValidationErrorMatch("nomatch", "nomatch", "nomatch", "nomatch", validationResult))
194-
require.True(t, ValidationErrorMatch("", "", "", "^#/property1$", validationResult))
193+
assert.False(t, ValidationErrorMatch("nomatch", "nomatch", "nomatch", "nomatch", validationResult))
194+
assert.True(t, ValidationErrorMatch("", "", "", "^#/property1$", validationResult))
195195
}
196196

197197
func Test_loadReferencedSchema(t *testing.T) {
198198
compiler := jsonschema.NewCompiler()
199199

200-
require.Panics(
200+
assert.Panics(
201201
t,
202202
func() {
203203
loadReferencedSchema(compiler, "nonexistent.json", testdata.Asset)
204204
},
205205
)
206-
require.Error(t, loadReferencedSchema(compiler, "schema-without-id.json", testdata.Asset))
207-
require.Nil(t, loadReferencedSchema(compiler, "referenced-schema-2.json", testdata.Asset))
206+
assert.Error(t, loadReferencedSchema(compiler, "schema-without-id.json", testdata.Asset))
207+
assert.Nil(t, loadReferencedSchema(compiler, "referenced-schema-2.json", testdata.Asset))
208208
}
209209

210210
func Test_schemaID(t *testing.T) {
211211
_, err := schemaID("schema-without-id.json", testdata.Asset)
212-
require.NotNil(t, err)
212+
assert.NotNil(t, err)
213213

214214
id, err := schemaID("valid-schema.json", testdata.Asset)
215-
require.Equal(t, "https://raw.githubusercontent.com/arduino/arduino-lint/main/internal/rule/schema/testdata/schema-with-references.json", id)
216-
require.Nil(t, err)
215+
assert.Equal(t, "https://raw.githubusercontent.com/arduino/arduino-lint/main/internal/rule/schema/testdata/schema-with-references.json", id)
216+
assert.Nil(t, err)
217217
}
218218

219219
func Test_validationErrorSchemaPointerValue(t *testing.T) {
@@ -227,17 +227,17 @@ func Test_validationErrorSchemaPointerValue(t *testing.T) {
227227

228228
schemaPointerValueInterface := validationErrorSchemaPointerValue(validationError)
229229
schemaPointerValue, ok := schemaPointerValueInterface.(string)
230-
require.True(t, ok)
231-
require.Equal(t, "^[a-z]+$", schemaPointerValue)
230+
assert.True(t, ok)
231+
assert.Equal(t, "^[a-z]+$", schemaPointerValue)
232232
}
233233

234234
func Test_validationErrorContextMatch(t *testing.T) {
235235
validationError := jsonschema.ValidationError{
236236
Context: nil,
237237
}
238238

239-
require.True(t, validationErrorContextMatch(regexp.MustCompile(".*"), &validationError))
240-
require.False(t, validationErrorContextMatch(regexp.MustCompile("foo"), &validationError))
239+
assert.True(t, validationErrorContextMatch(regexp.MustCompile(".*"), &validationError))
240+
assert.False(t, validationErrorContextMatch(regexp.MustCompile("foo"), &validationError))
241241

242242
validationError.Context = &jsonschema.ValidationErrorContextRequired{
243243
Missing: []string{
@@ -246,6 +246,6 @@ func Test_validationErrorContextMatch(t *testing.T) {
246246
},
247247
}
248248

249-
require.True(t, validationErrorContextMatch(regexp.MustCompile("^#/bar$"), &validationError))
250-
require.False(t, validationErrorContextMatch(regexp.MustCompile("nomatch"), &validationError))
249+
assert.True(t, validationErrorContextMatch(regexp.MustCompile("^#/bar$"), &validationError))
250+
assert.False(t, validationErrorContextMatch(regexp.MustCompile("nomatch"), &validationError))
251251
}

0 commit comments

Comments
 (0)