@@ -11,12 +11,11 @@ import (
1111 "net"
1212 "net/http"
1313 "os"
14+ "reflect"
1415 "runtime"
1516 "strings"
1617 "time"
1718
18- "github.com/sergi/go-diff/diffmatchpatch"
19-
2019 "github.com/dependabot/cli/internal/model"
2120 "gopkg.in/yaml.v3"
2221)
@@ -110,8 +109,12 @@ func (a *API) ServeHTTP(_ http.ResponseWriter, r *http.Request) {
110109
111110 parts := strings .Split (r .URL .String (), "/" )
112111 kind := parts [len (parts )- 1 ]
112+ actual , err := decodeWrapper (kind , data )
113+ if err != nil {
114+ a .pushError (err )
115+ }
113116
114- if err := a .pushResult (kind , data ); err != nil {
117+ if err := a .pushResult (kind , actual ); err != nil {
115118 a .pushError (err )
116119 return
117120 }
@@ -120,10 +123,10 @@ func (a *API) ServeHTTP(_ http.ResponseWriter, r *http.Request) {
120123 return
121124 }
122125
123- a .assertExpectation (kind , data )
126+ a .assertExpectation (kind , actual )
124127}
125128
126- func (a * API ) assertExpectation (kind string , actualData [] byte ) {
129+ func (a * API ) assertExpectation (kind string , actual * model. UpdateWrapper ) {
127130 if len (a .Expectations ) <= a .cursor {
128131 err := fmt .Errorf ("missing expectation" )
129132 a .pushError (err )
@@ -134,24 +137,19 @@ func (a *API) assertExpectation(kind string, actualData []byte) {
134137 if kind != expect .Type {
135138 err := fmt .Errorf ("type was unexpected: expected %v got %v" , expect .Type , kind )
136139 a .pushError (err )
140+ return
137141 }
138- expectJSON , _ := json .Marshal (expect .Expect )
139- // pretty both for sorting and can use simple comparison
140- prettyData , _ := pretty (string (expectJSON ))
141- actual , _ := pretty (string (actualData ))
142- if actual != prettyData {
143- err := fmt .Errorf ("expected output doesn't match actual data received" )
142+ // need to use decodeWrapper to get the right type to match the actual type
143+ data , err := json .Marshal (expect .Expect )
144+ if err != nil {
145+ panic (err )
146+ }
147+ expected , err := decodeWrapper (expect .Type , data )
148+ if err != nil {
149+ panic (err )
150+ }
151+ if err = compare (expected , actual ); err != nil {
144152 a .pushError (err )
145-
146- // print diff to stdout
147- dmp := diffmatchpatch .New ()
148-
149- const checklines = false
150- diffs := dmp .DiffMain (prettyData , actual , checklines )
151-
152- diffs = dmp .DiffCleanupSemantic (diffs )
153-
154- fmt .Println (dmp .DiffPrettyText (diffs ))
155153 }
156154}
157155
@@ -162,11 +160,7 @@ func (a *API) pushError(err error) {
162160 a .Errors = append (a .Errors , err )
163161}
164162
165- func (a * API ) pushResult (kind string , data []byte ) error {
166- actual , err := decodeWrapper (kind , data )
167- if err != nil {
168- return err
169- }
163+ func (a * API ) pushResult (kind string , actual * model.UpdateWrapper ) error {
170164 // TODO validate required data
171165 output := model.Output {
172166 Type : kind ,
@@ -182,66 +176,108 @@ func (a *API) pushResult(kind string, data []byte) error {
182176 return nil
183177}
184178
185- // pretty indents and sorts the keys for a consistent comparison
186- func pretty (jsonString string ) (string , error ) {
187- var v map [string ]any
188- if err := json .Unmarshal ([]byte (jsonString ), & v ); err != nil {
189- return "" , err
190- }
191- removeNullsFromObjects (v )
192- // shouldn't be possible to error
193- b , _ := json .MarshalIndent (v , "" , " " )
194- return string (b ), nil
195- }
196-
197- func removeNullsFromObjects (m map [string ]any ) {
198- for k , v := range m {
199- switch assertedVal := v .(type ) {
200- case nil :
201- delete (m , k )
202- case map [string ]any :
203- removeNullsFromObjects (assertedVal )
204- case []any :
205- for _ , item := range assertedVal {
206- switch assertedItem := item .(type ) {
207- case map [string ]any :
208- removeNullsFromObjects (assertedItem )
209- }
210- }
211- }
212- }
213- }
214-
215- func decodeWrapper (kind string , data []byte ) (* model.UpdateWrapper , error ) {
216- var actual model.UpdateWrapper
179+ func decodeWrapper (kind string , data []byte ) (actual * model.UpdateWrapper , err error ) {
180+ actual = & model.UpdateWrapper {}
217181 switch kind {
218182 case "update_dependency_list" :
219- actual .Data = decode [model.UpdateDependencyList ](data )
183+ actual .Data , err = decode [model.UpdateDependencyList ](data )
220184 case "create_pull_request" :
221- actual .Data = decode [model.CreatePullRequest ](data )
185+ actual .Data , err = decode [model.CreatePullRequest ](data )
222186 case "update_pull_request" :
223- actual .Data = decode [model.UpdatePullRequest ](data )
187+ actual .Data , err = decode [model.UpdatePullRequest ](data )
224188 case "close_pull_request" :
225- actual .Data = decode [model.ClosePullRequest ](data )
189+ actual .Data , err = decode [model.ClosePullRequest ](data )
226190 case "mark_as_processed" :
227- actual .Data = decode [model.MarkAsProcessed ](data )
191+ actual .Data , err = decode [model.MarkAsProcessed ](data )
228192 case "record_package_manager_version" :
229- actual .Data = decode [model.RecordPackageManagerVersion ](data )
193+ actual .Data , err = decode [model.RecordPackageManagerVersion ](data )
230194 case "record_update_job_error" :
231- actual .Data = decode [map [ string ] any ](data )
195+ actual .Data , err = decode [model. RecordUpdateJobError ](data )
232196 default :
233197 return nil , fmt .Errorf ("unexpected output type: %s" , kind )
234198 }
235- return & actual , nil
199+ return actual , err
236200}
237201
238- func decode [T any ](data []byte ) any {
202+ func decode [T any ](data []byte ) ( any , error ) {
239203 var wrapper struct {
240204 Data T `json:"data" yaml:"data"`
241205 }
242- err := yaml .NewDecoder (bytes .NewBuffer (data )).Decode (& wrapper )
206+ decoder := yaml .NewDecoder (bytes .NewBuffer (data ))
207+ decoder .KnownFields (true )
208+ err := decoder .Decode (& wrapper )
243209 if err != nil {
244- panic (err )
210+ return nil , err
211+ }
212+ return wrapper .Data , nil
213+ }
214+
215+ func compare (expect , actual * model.UpdateWrapper ) error {
216+ switch v := expect .Data .(type ) {
217+ case model.UpdateDependencyList :
218+ return compareUpdateDependencyList (v , actual .Data .(model.UpdateDependencyList ))
219+ case model.CreatePullRequest :
220+ return compareCreatePullRequest (v , actual .Data .(model.CreatePullRequest ))
221+ case model.UpdatePullRequest :
222+ return compareUpdatePullRequest (v , actual .Data .(model.UpdatePullRequest ))
223+ case model.ClosePullRequest :
224+ return compareClosePullRequest (v , actual .Data .(model.ClosePullRequest ))
225+ case model.RecordPackageManagerVersion :
226+ return compareRecordPackageManagerVersion (v , actual .Data .(model.RecordPackageManagerVersion ))
227+ case model.MarkAsProcessed :
228+ return compareMarkAsProcessed (v , actual .Data .(model.MarkAsProcessed ))
229+ case model.RecordUpdateJobError :
230+ return compareRecordUpdateJobError (v , actual .Data .(model.RecordUpdateJobError ))
231+ default :
232+ return fmt .Errorf ("unexpected type: %s" , reflect .TypeOf (v ))
233+ }
234+ }
235+
236+ func compareUpdateDependencyList (expect , actual model.UpdateDependencyList ) error {
237+ if reflect .DeepEqual (expect , actual ) {
238+ return nil
239+ }
240+ return fmt .Errorf ("dependency list was unexpected" )
241+ }
242+
243+ func compareCreatePullRequest (expect , actual model.CreatePullRequest ) error {
244+ if reflect .DeepEqual (expect , actual ) {
245+ return nil
246+ }
247+ return fmt .Errorf ("create pull request was unexpected" )
248+ }
249+
250+ func compareUpdatePullRequest (expect , actual model.UpdatePullRequest ) error {
251+ if reflect .DeepEqual (expect , actual ) {
252+ return nil
253+ }
254+ return fmt .Errorf ("update pull request was unexpected" )
255+ }
256+
257+ func compareClosePullRequest (expect , actual model.ClosePullRequest ) error {
258+ if reflect .DeepEqual (expect , actual ) {
259+ return nil
260+ }
261+ return fmt .Errorf ("close pull request was unexpected" )
262+ }
263+
264+ func compareRecordPackageManagerVersion (expect , actual model.RecordPackageManagerVersion ) error {
265+ if reflect .DeepEqual (expect , actual ) {
266+ return nil
267+ }
268+ return fmt .Errorf ("record package manager version was unexpected" )
269+ }
270+
271+ func compareMarkAsProcessed (expect , actual model.MarkAsProcessed ) error {
272+ if reflect .DeepEqual (expect , actual ) {
273+ return nil
274+ }
275+ return fmt .Errorf ("mark as processed was unexpected" )
276+ }
277+
278+ func compareRecordUpdateJobError (expect , actual model.RecordUpdateJobError ) error {
279+ if reflect .DeepEqual (expect , actual ) {
280+ return nil
245281 }
246- return wrapper . Data
282+ return fmt . Errorf ( "record update job error was unexpected" )
247283}
0 commit comments