ghrepos 2.1.0 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/.github/dependabot.yml +20 -0
  2. package/.github/workflows/test-and-release.yml +56 -0
  3. package/CHANGELOG.md +13 -0
  4. package/README.md +64 -146
  5. package/examples/commit-comments.js +11 -13
  6. package/ghrepos.js +52 -89
  7. package/package.json +101 -8
  8. package/test.js +196 -371
  9. package/.jshintrc +0 -59
  10. package/.travis.yml +0 -17
package/test.js CHANGED
@@ -1,427 +1,252 @@
1
- const ghutils = require('ghutils/test-util')
2
- , ghrepos = require('./')
3
- , test = require('tape')
4
- , xtend = require('xtend')
5
-
6
-
7
- test('test list repos for user', function (t) {
8
- t.plan(10)
9
-
10
- var auth = { user: 'authuser', token: 'authtoken' }
11
- , user = 'testuser'
12
- , testData = [
13
- {
14
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
15
- , headers : { link: '<https://somenexturl>; rel="next"' }
16
- }
17
- , []
18
- ]
19
- , server
20
-
21
- server = ghutils.makeServer(testData)
22
- .on('ready', function () {
23
- var result = testData[0].response
24
- ghrepos.listUser(xtend(auth), user, ghutils.verifyData(t, result))
1
+ import { test } from 'node:test'
2
+ import assert from 'node:assert'
3
+ import { createMockServer, createMockServerWithHandler } from 'ghutils/test-util'
4
+ import * as ghrepos from './ghrepos.js'
5
+
6
+ test('list repos for user', async () => {
7
+ const auth = { token: 'test-token' }
8
+ const testData = [{ id: 1, name: 'repo1' }, { id: 2, name: 'repo2' }]
9
+
10
+ const server = await createMockServer({ response: testData })
11
+ try {
12
+ const results = await ghrepos.listUser(auth, 'testuser', {
13
+ _apiUrl: server.baseUrl
25
14
  })
26
- .on('request', ghutils.verifyRequest(t, auth))
27
- .on('get', ghutils.verifyUrl(t, [
28
- 'https://api.github.com/users/testuser/repos?'
29
- , 'https://somenexturl'
30
- ]))
31
- .on('close' , ghutils.verifyClose(t))
15
+ assert.deepStrictEqual(results, testData)
16
+ assert.ok(server.requests[0].url.includes('/users/testuser/repos'))
17
+ assert.strictEqual(server.requests[0].headers.authorization, 'Bearer test-token')
18
+ } finally {
19
+ await server.close()
20
+ }
32
21
  })
33
22
 
34
- test('test list repos for org', function (t) {
35
- t.plan(10)
36
-
37
- var auth = { user: 'authuser', token: 'authtoken' }
38
- , org = 'testorg'
39
- , testData = [
40
- {
41
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
42
- , headers : { link: '<https://somenexturl>; rel="next"' }
43
- }
44
- , []
45
- ]
46
- , server
23
+ test('list repos for authed user (no user arg)', async () => {
24
+ const auth = { token: 'test-token' }
25
+ const testData = [{ id: 1, name: 'repo1' }]
47
26
 
48
- server = ghutils.makeServer(testData)
49
- .on('ready', function () {
50
- var result = testData[0].response
51
- ghrepos.listOrg(xtend(auth), org, ghutils.verifyData(t, result))
27
+ const server = await createMockServer({ response: testData })
28
+ try {
29
+ const results = await ghrepos.listUser(auth, null, {
30
+ _apiUrl: server.baseUrl
52
31
  })
53
- .on('request', ghutils.verifyRequest(t, auth))
54
- .on('get', ghutils.verifyUrl(t, [
55
- 'https://api.github.com/orgs/testorg/repos?'
56
- , 'https://somenexturl'
57
- ]))
58
- .on('close' , ghutils.verifyClose(t))
32
+ assert.deepStrictEqual(results, testData)
33
+ assert.ok(server.requests[0].url.includes('/user/repos'))
34
+ } finally {
35
+ await server.close()
36
+ }
59
37
  })
60
38
 
61
- test('test list repos for authed user', function (t) {
62
- t.plan(10)
39
+ test('list repos for org', async () => {
40
+ const auth = { token: 'test-token' }
41
+ const testData = [{ id: 1, name: 'repo1' }]
63
42
 
64
- var auth = { user: 'authuser', token: 'authtoken' }
65
- , testData = [
66
- {
67
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
68
- , headers : { link: '<https://somenexturl>; rel="next"' }
69
- }
70
- , []
71
- ]
72
- , server
73
-
74
- server = ghutils.makeServer(testData)
75
- .on('ready', function () {
76
- var result = testData[0].response
77
- ghrepos.listUser(xtend(auth), ghutils.verifyData(t, result))
43
+ const server = await createMockServer({ response: testData })
44
+ try {
45
+ const results = await ghrepos.listOrg(auth, 'testorg', {
46
+ _apiUrl: server.baseUrl
78
47
  })
79
- .on('request', ghutils.verifyRequest(t, auth))
80
- .on('get', ghutils.verifyUrl(t, [
81
- 'https://api.github.com/user/repos'
82
- , 'https://somenexturl'
83
- ]))
84
- .on('close' , ghutils.verifyClose(t))
48
+ assert.deepStrictEqual(results, testData)
49
+ assert.ok(server.requests[0].url.includes('/orgs/testorg/repos'))
50
+ } finally {
51
+ await server.close()
52
+ }
85
53
  })
86
54
 
87
-
88
- test('test list repos for authed user with multi-page', function (t) {
89
- t.plan(13)
90
-
91
- var auth = { user: 'authuser', token: 'authtoken' }
92
- , testData = [
93
- {
94
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
95
- , headers : { link: '<https://somenexturl>; rel="next"' }
96
- }
97
- , {
98
- response : [ { test5: 'data5' }, { test6: 'data6' } ]
99
- , headers : { link: '<https://somenexturl2>; rel="next"' }
100
- }
101
- , []
102
- ]
103
- , server
104
-
105
- server = ghutils.makeServer(testData)
106
- .on('ready', function () {
107
- var result = testData[0].response.concat(testData[1].response)
108
- ghrepos.listUser(xtend(auth), ghutils.verifyData(t, result))
55
+ test('list repos with pagination', async () => {
56
+ const auth = { token: 'test-token' }
57
+ const page1 = [{ id: 1 }, { id: 2 }]
58
+ const page2 = [{ id: 3 }, { id: 4 }]
59
+
60
+ let requestCount = 0
61
+ const mock = await createMockServerWithHandler((req, res) => {
62
+ requestCount++
63
+ const port = mock.address().port
64
+ if (requestCount === 1) {
65
+ res.setHeader('link', `<http://127.0.0.1:${port}/page2>; rel="next"`)
66
+ res.end(JSON.stringify(page1))
67
+ } else {
68
+ res.end(JSON.stringify(page2))
69
+ }
70
+ })
71
+
72
+ try {
73
+ const results = await ghrepos.listUser(auth, 'testuser', {
74
+ _apiUrl: mock.baseUrl
109
75
  })
110
- .on('request', ghutils.verifyRequest(t, auth))
111
- .on('get', ghutils.verifyUrl(t, [
112
- 'https://api.github.com/user/repos'
113
- , 'https://somenexturl'
114
- , 'https://somenexturl2'
115
- ]))
116
- .on('close' , ghutils.verifyClose(t))
76
+ assert.deepStrictEqual(results, [...page1, ...page2])
77
+ assert.strictEqual(requestCount, 2)
78
+ } finally {
79
+ await mock.close()
80
+ }
117
81
  })
118
82
 
83
+ test('list refs', async () => {
84
+ const auth = { token: 'test-token' }
85
+ const refs = [{ ref: 'refs/heads/main' }, { ref: 'refs/tags/v1' }]
119
86
 
120
- test('test list repos for authed user with no repos', function (t) {
121
- t.plan(7)
122
-
123
- var auth = { user: 'authuser', token: 'authtoken' }
124
- , testData = [ [] ]
125
- , server
126
-
127
- server = ghutils.makeServer(testData)
128
- .on('ready', function () {
129
- ghrepos.listUser(xtend(auth), ghutils.verifyData(t, []))
87
+ const server = await createMockServer({ response: refs })
88
+ try {
89
+ const results = await ghrepos.listRefs(auth, 'testorg', 'testrepo', {
90
+ _apiUrl: server.baseUrl
130
91
  })
131
- .on('request', ghutils.verifyRequest(t, auth))
132
- .on('get', ghutils.verifyUrl(t, [
133
- 'https://api.github.com/user/repos'
134
- ]))
135
- .on('close' , ghutils.verifyClose(t))
92
+ assert.deepStrictEqual(results, refs)
93
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/git/refs'))
94
+ } finally {
95
+ await server.close()
96
+ }
136
97
  })
137
98
 
99
+ test('list tags', async () => {
100
+ const auth = { token: 'test-token' }
101
+ const tags = [{ name: 'v1.0.0' }, { name: 'v2.0.0' }]
138
102
 
139
- test('test get ref list for a repo', function (t) {
140
- t.plan(13)
141
-
142
- var auth = { user: 'authuser', token: 'authtoken' }
143
- , org = 'testorg'
144
- , repo = 'testrepo'
145
- , testData = [
146
- {
147
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
148
- , headers : { link: '<https://somenexturl>; rel="next"' }
149
- }
150
- , {
151
- response : [ { test5: 'data5' }, { test6: 'data6' } ]
152
- , headers : { link: '<https://somenexturl2>; rel="next"' }
153
- }
154
- , []
155
- ]
156
- , server
157
-
158
- server = ghutils.makeServer(testData)
159
- .on('ready', function () {
160
- var result = testData[0].response.concat(testData[1].response)
161
- ghrepos.listRefs(xtend(auth), org, repo, ghutils.verifyData(t, result))
103
+ const server = await createMockServer({ response: tags })
104
+ try {
105
+ const results = await ghrepos.listTags(auth, 'testorg', 'testrepo', {
106
+ _apiUrl: server.baseUrl
162
107
  })
163
- .on('request', ghutils.verifyRequest(t, auth))
164
- .on('get', ghutils.verifyUrl(t, [
165
- 'https://api.github.com/repos/' + org + '/' + repo + '/git/refs'
166
- , 'https://somenexturl'
167
- , 'https://somenexturl2'
168
- ]))
169
- .on('close' , ghutils.verifyClose(t))
108
+ assert.deepStrictEqual(results, tags)
109
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/tags'))
110
+ } finally {
111
+ await server.close()
112
+ }
170
113
  })
171
114
 
115
+ test('list branches', async () => {
116
+ const auth = { token: 'test-token' }
117
+ const branches = [{ name: 'main' }, { name: 'dev' }]
172
118
 
173
- test('test get branch list for a repo', function (t) {
174
- t.plan(13)
175
-
176
- var auth = { user: 'authuser', token: 'authtoken' }
177
- , org = 'testorg'
178
- , repo = 'testrepo'
179
- , testData = [
180
- {
181
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
182
- , headers : { link: '<https://somenexturl>; rel="next"' }
183
- }
184
- , {
185
- response : [ { test5: 'data5' }, { test6: 'data6' } ]
186
- , headers : { link: '<https://somenexturl2>; rel="next"' }
187
- }
188
- , []
189
- ]
190
- , server
191
-
192
- server = ghutils.makeServer(testData)
193
- .on('ready', function () {
194
- var result = testData[0].response.concat(testData[1].response)
195
- ghrepos.listBranches(xtend(auth), org, repo, ghutils.verifyData(t, result))
119
+ const server = await createMockServer({ response: branches })
120
+ try {
121
+ const results = await ghrepos.listBranches(auth, 'testorg', 'testrepo', {
122
+ _apiUrl: server.baseUrl
196
123
  })
197
- .on('request', ghutils.verifyRequest(t, auth))
198
- .on('get', ghutils.verifyUrl(t, [
199
- 'https://api.github.com/repos/' + org + '/' + repo + '/branches'
200
- , 'https://somenexturl'
201
- , 'https://somenexturl2'
202
- ]))
203
- .on('close' , ghutils.verifyClose(t))
124
+ assert.deepStrictEqual(results, branches)
125
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/branches'))
126
+ } finally {
127
+ await server.close()
128
+ }
204
129
  })
205
130
 
131
+ test('list commits', async () => {
132
+ const auth = { token: 'test-token' }
133
+ const commits = [{ sha: 'abc123' }, { sha: 'def456' }]
206
134
 
207
- test('test get tag list for a repo', function (t) {
208
- t.plan(13)
209
-
210
- var auth = { user: 'authuser', token: 'authtoken' }
211
- , org = 'testorg'
212
- , repo = 'testrepo'
213
- , testData = [
214
- {
215
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
216
- , headers : { link: '<https://somenexturl>; rel="next"' }
217
- }
218
- , {
219
- response : [ { test5: 'data5' }, { test6: 'data6' } ]
220
- , headers : { link: '<https://somenexturl2>; rel="next"' }
221
- }
222
- , []
223
- ]
224
- , server
225
-
226
- server = ghutils.makeServer(testData)
227
- .on('ready', function () {
228
- var result = testData[0].response.concat(testData[1].response)
229
- ghrepos.listTags(xtend(auth), org, repo, ghutils.verifyData(t, result))
135
+ const server = await createMockServer({ response: commits })
136
+ try {
137
+ const results = await ghrepos.listCommits(auth, 'testorg', 'testrepo', {
138
+ _apiUrl: server.baseUrl
230
139
  })
231
- .on('request', ghutils.verifyRequest(t, auth))
232
- .on('get', ghutils.verifyUrl(t, [
233
- 'https://api.github.com/repos/' + org + '/' + repo + '/tags'
234
- , 'https://somenexturl'
235
- , 'https://somenexturl2'
236
- ]))
237
- .on('close' , ghutils.verifyClose(t))
140
+ assert.deepStrictEqual(results, commits)
141
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/commits'))
142
+ } finally {
143
+ await server.close()
144
+ }
238
145
  })
239
146
 
147
+ test('get ref', async () => {
148
+ const auth = { token: 'test-token' }
149
+ const refData = { ref: 'refs/heads/main', object: { sha: 'abc123' } }
240
150
 
241
- test('test get ref data for a ref', function (t) {
242
- t.plan(7)
243
-
244
- var auth = { user: 'authuser', token: 'authtoken' }
245
- , org = 'testorg'
246
- , repo = 'testrepo'
247
- , ref = 'head/testref'
248
- , testData = [
249
- { test3: 'data3' }
250
- ]
251
- , server
252
-
253
- server = ghutils.makeServer(testData)
254
- .on('ready', function () {
255
- ghrepos.getRef(xtend(auth), org, repo, ref, ghutils.verifyData(t, testData[0]))
151
+ const server = await createMockServer({ response: refData })
152
+ try {
153
+ const result = await ghrepos.getRef(auth, 'testorg', 'testrepo', 'heads/main', {
154
+ _apiUrl: server.baseUrl
256
155
  })
257
- .on('request', ghutils.verifyRequest(t, auth))
258
- .on('get', ghutils.verifyUrl(t, [
259
- 'https://api.github.com/repos/' + org + '/' + repo + '/git/refs/' + ref
260
- ]))
261
- .on('close' , ghutils.verifyClose(t))
156
+ assert.deepStrictEqual(result, refData)
157
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/git/refs/heads/main'))
158
+ } finally {
159
+ await server.close()
160
+ }
262
161
  })
263
162
 
163
+ test('get ref strips refs/ prefix', async () => {
164
+ const auth = { token: 'test-token' }
165
+ const refData = { ref: 'refs/heads/main' }
264
166
 
265
- test('test get branch data for a branch', function (t) {
266
- t.plan(7)
267
-
268
- var auth = { user: 'authuser', token: 'authtoken' }
269
- , org = 'testorg'
270
- , repo = 'testrepo'
271
- , branch = 'testbranch'
272
- , testData = [
273
- { test3: 'data3' }
274
- ]
275
- , server
276
-
277
- server = ghutils.makeServer(testData)
278
- .on('ready', function () {
279
- ghrepos.getBranch(xtend(auth), org, repo, branch, ghutils.verifyData(t, testData[0]))
167
+ const server = await createMockServer({ response: refData })
168
+ try {
169
+ await ghrepos.getRef(auth, 'testorg', 'testrepo', 'refs/heads/main', {
170
+ _apiUrl: server.baseUrl
280
171
  })
281
- .on('request', ghutils.verifyRequest(t, auth))
282
- .on('get', ghutils.verifyUrl(t, [
283
- 'https://api.github.com/repos/' + org + '/' + repo + '/branches/' + branch
284
- ]))
285
- .on('close' , ghutils.verifyClose(t))
172
+ assert.ok(server.requests[0].url.includes('/git/refs/heads/main'))
173
+ assert.ok(!server.requests[0].url.includes('/git/refs/refs/'))
174
+ } finally {
175
+ await server.close()
176
+ }
286
177
  })
287
178
 
179
+ test('get branch', async () => {
180
+ const auth = { token: 'test-token' }
181
+ const branchData = { name: 'main', commit: { sha: 'abc123' } }
288
182
 
289
- test('test get ref data for a ref with refs/ prefix', function (t) {
290
- t.plan(7)
291
-
292
- var auth = { user: 'authuser', token: 'authtoken' }
293
- , org = 'testorg'
294
- , repo = 'testrepo'
295
- , ref = 'head/testref'
296
- , testData = [
297
- { test3: 'data3' }
298
- ]
299
- , server
300
-
301
- server = ghutils.makeServer(testData)
302
- .on('ready', function () {
303
- ghrepos.getRef(xtend(auth), org, repo, 'refs/' + ref, ghutils.verifyData(t, testData[0]))
183
+ const server = await createMockServer({ response: branchData })
184
+ try {
185
+ const result = await ghrepos.getBranch(auth, 'testorg', 'testrepo', 'main', {
186
+ _apiUrl: server.baseUrl
304
187
  })
305
- .on('request', ghutils.verifyRequest(t, auth))
306
- .on('get', ghutils.verifyUrl(t, [
307
- 'https://api.github.com/repos/' + org + '/' + repo + '/git/refs/' + ref
308
- ]))
309
- .on('close' , ghutils.verifyClose(t))
188
+ assert.deepStrictEqual(result, branchData)
189
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/branches/main'))
190
+ } finally {
191
+ await server.close()
192
+ }
310
193
  })
311
194
 
195
+ test('get commit', async () => {
196
+ const auth = { token: 'test-token' }
197
+ const commitData = { sha: 'abc123', author: { login: 'testuser' } }
312
198
 
313
- test('test list commits for authed user', function (t) {
314
- t.plan(10)
315
-
316
- var auth = { user: 'authuser', token: 'authtoken' }
317
- , org = 'testorg'
318
- , repo = 'testrepo'
319
- , testData = [
320
- {
321
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
322
- , headers : { link: '<https://somenexturl>; rel="next"' }
323
- }
324
- , []
325
- ]
326
- , server
327
-
328
- server = ghutils.makeServer(testData)
329
- .on('ready', function () {
330
- var result = testData[0].response
331
- ghrepos.listCommits(xtend(auth), org, repo, ghutils.verifyData(t, result))
199
+ const server = await createMockServer({ response: commitData })
200
+ try {
201
+ const result = await ghrepos.getCommit(auth, 'testorg', 'testrepo', 'abc123', {
202
+ _apiUrl: server.baseUrl
332
203
  })
333
- .on('request', ghutils.verifyRequest(t, auth))
334
- .on('get', ghutils.verifyUrl(t, [
335
- 'https://api.github.com/repos/testorg/testrepo/commits'
336
- , 'https://somenexturl'
337
- ]))
338
- .on('close' , ghutils.verifyClose(t))
204
+ assert.deepStrictEqual(result, commitData)
205
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/commits/abc123'))
206
+ } finally {
207
+ await server.close()
208
+ }
339
209
  })
340
210
 
211
+ test('get commit comments', async () => {
212
+ const auth = { token: 'test-token' }
213
+ const comments = [{ id: 1, body: 'nice' }]
341
214
 
342
- test('test get commit for authed user', function (t) {
343
- t.plan(7)
344
-
345
- var auth = { user: 'authuser', token: 'authtoken' }
346
- , org = 'testorg'
347
- , repo = 'testrepo'
348
- , ref = 'aaee1122'
349
- , testData = [
350
- {
351
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
352
- , headers : { link: '<https://somenexturl>; rel="next"' }
353
- }
354
- ]
355
- , server
356
-
357
- server = ghutils.makeServer(testData)
358
- .on('ready', function () {
359
- var result = testData[0].response
360
- ghrepos.getCommit(xtend(auth), org, repo, ref, ghutils.verifyData(t, result))
215
+ const server = await createMockServer({ response: comments })
216
+ try {
217
+ const result = await ghrepos.getCommitComments(auth, 'testorg', 'testrepo', 'abc123', {
218
+ _apiUrl: server.baseUrl
361
219
  })
362
- .on('request', ghutils.verifyRequest(t, auth))
363
- .on('get', ghutils.verifyUrl(t, [
364
- 'https://api.github.com/repos/testorg/testrepo/commits/aaee1122'
365
- , 'https://somenexturl'
366
- ]))
367
- .on('close' , ghutils.verifyClose(t))
220
+ assert.deepStrictEqual(result, comments)
221
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/commits/abc123/comments'))
222
+ } finally {
223
+ await server.close()
224
+ }
368
225
  })
369
226
 
227
+ test('createLister produces working lister', async () => {
228
+ const auth = { token: 'test-token' }
229
+ const data = [{ id: 1 }, { id: 2 }]
230
+ const customLister = ghrepos.createLister('footype')
370
231
 
371
- test('test get commit comments for authed user', function (t) {
372
- t.plan(7)
373
-
374
- var auth = { user: 'authuser', token: 'authtoken' }
375
- , org = 'testorg'
376
- , repo = 'testrepo'
377
- , ref = 'aaee1122'
378
- , testData = [
379
- {
380
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
381
- , headers : { link: '<https://somenexturl>; rel="next"' }
382
- }
383
- ]
384
- , server
385
-
386
- server = ghutils.makeServer(testData)
387
- .on('ready', function () {
388
- var result = testData[0].response
389
- ghrepos.getCommitComments(xtend(auth), org, repo, ref, ghutils.verifyData(t, result))
232
+ const server = await createMockServer({ response: data })
233
+ try {
234
+ const results = await customLister(auth, 'testorg', 'testrepo', {
235
+ _apiUrl: server.baseUrl
390
236
  })
391
- .on('request', ghutils.verifyRequest(t, auth))
392
- .on('get', ghutils.verifyUrl(t, [
393
- 'https://api.github.com/repos/testorg/testrepo/commits/aaee1122/comments'
394
- , 'https://somenexturl'
395
- ]))
396
- .on('close' , ghutils.verifyClose(t))
237
+ assert.deepStrictEqual(results, data)
238
+ assert.ok(server.requests[0].url.includes('/repos/testorg/testrepo/footype'))
239
+ } finally {
240
+ await server.close()
241
+ }
397
242
  })
398
243
 
244
+ test('baseUrl returns correct URL', () => {
245
+ const url = ghrepos.baseUrl('myorg', 'myrepo')
246
+ assert.strictEqual(url, 'https://api.github.com/repos/myorg/myrepo')
247
+ })
399
248
 
400
- test('test footype repo lister', function (t) {
401
- t.plan(10)
402
-
403
- var auth = { user: 'authuser', token: 'authtoken' }
404
- , org = 'testorg'
405
- , repo = 'testrepo'
406
- , testData = [
407
- {
408
- response : [ { test3: 'data3' }, { test4: 'data4' } ]
409
- , headers : { link: '<https://somenexturl>; rel="next"' }
410
- }
411
- , []
412
- ]
413
- , lister = ghrepos.createLister('footype')
414
- , server
415
-
416
- server = ghutils.makeServer(testData)
417
- .on('ready', function () {
418
- var result = testData[0].response
419
- lister(xtend(auth), org, repo, ghutils.verifyData(t, result))
420
- })
421
- .on('request', ghutils.verifyRequest(t, auth))
422
- .on('get', ghutils.verifyUrl(t, [
423
- 'https://api.github.com/repos/' + org + '/' + repo + '/footype'
424
- , 'https://somenexturl'
425
- ]))
426
- .on('close' , ghutils.verifyClose(t))
249
+ test('baseUrl respects _apiUrl option', () => {
250
+ const url = ghrepos.baseUrl('myorg', 'myrepo', { _apiUrl: 'http://localhost:3000' })
251
+ assert.strictEqual(url, 'http://localhost:3000/repos/myorg/myrepo')
427
252
  })