Improve our approach for testing auth (part 1)

services/stackexchange/stackexchange-monthlyquestions.spec.js

@@ -0,0 +1,10 @@
+import { testAuth } from '../test-helpers.js'
+import StackExchangeMonthlyQuestions from './stackexchange-monthlyquestions.service.js'
+
+describe('StackExchangeMonthlyQuestions', function () {
+  describe('auth', function () {
+    it('sends the auth information as configured', async function () {
+      return testAuth(StackExchangeMonthlyQuestions, { total: 8 })
+    })
+  })
+})

services/stackexchange/stackexchange-reputation.spec.js

@@ -0,0 +1,10 @@
+import { testAuth } from '../test-helpers.js'
+import StackExchangeReputation from './stackexchange-reputation.service.js'
+
+describe('StackExchangeReputation', function () {
+  describe('auth', function () {
+    it('sends the auth information as configured', async function () {
+      return testAuth(StackExchangeReputation, { items: [{ reputation: 8 }] })
+    })
+  })
+})

services/stackexchange/stackexchange-taginfo.spec.js

@@ -0,0 +1,10 @@
+import { testAuth } from '../test-helpers.js'
+import StackExchangeQuestions from './stackexchange-taginfo.service.js'
+
+describe('StackExchangeQuestions', function () {
+  describe('auth', function () {
+    it('sends the auth information as configured', async function () {
+      return testAuth(StackExchangeQuestions, { items: [{ count: 8 }] })
+    })
+  })
+})

services/test-helpers.js

@@ -1,6 +1,8 @@
+import { expect } from 'chai'
 import nock from 'nock'
 import config from 'config'
 import { fetch } from '../core/base-service/got.js'
+import BaseService from '../core/base-service/base.js'
 const runnerConfig = config.util.toObject()
 
 function cleanUpNockAfterEach() {
@@ -30,6 +32,99 @@ function noToken(serviceClass) {
   }
 }
 
+/**
+ * Retrieves an example set of parameters for invoking a service class using OpenAPI example of that class.
+ *
+ * @param {BaseService} serviceClass The service class containing OpenAPI specifications.
+ * @returns {object} An object with call params to use with a service invoke of the first OpenAPI example.
+ * @throws {TypeError} - Throws a TypeError if the input `serviceClass` is not an instance of BaseService,
+ *   or if it lacks the expected structure.
+ *
+ * @example
+ * // Example usage:
+ * const example = getBadgeExampleCall(StackExchangeReputation)
+ * console.log(example)
+ * // Output: { stackexchangesite: 'stackoverflow', query: '123' }
+ * StackExchangeReputation.invoke(defaultContext, config, example)
+ */
+function getBadgeExampleCall(serviceClass) {
+  if (!(serviceClass.prototype instanceof BaseService)) {
+    throw new TypeError(
+      'Invalid serviceClass: Must be an instance of BaseService.',
+    )
+  }
+
+  if (!serviceClass.openApi) {
+    throw new TypeError(
+      `Missing OpenAPI in service class ${serviceClass.name}.`,
+    )
+  }
+
+  const firstOpenapiPath = Object.keys(serviceClass.openApi)[0]
+
+  const firstOpenapiExampleParams =
+    serviceClass.openApi[firstOpenapiPath].get.parameters
+  if (!Array.isArray(firstOpenapiExampleParams)) {
+    throw new TypeError(
+      `Missing or invalid OpenAPI examples in ${serviceClass.name}.`,
+    )
+  }
+
+  // reformat structure for serviceClass.invoke
+  const exampleInvokeParams = firstOpenapiExampleParams.reduce((acc, obj) => {
+    acc[obj.name] = obj.example
+    return acc
+  }, {})
+
+  return exampleInvokeParams
+}
+
+/**
+ * Test authentication of a badge for it's first OpenAPI example using a provided dummyResponse
+ *
+ * @param {BaseService} serviceClass The service class tested.
+ * @param {object} dummyResponse An object containing the dummy response by the server.
+ * @throws {TypeError} - Throws a TypeError if the input `serviceClass` is not an instance of BaseService,
+ *   or if `serviceClass` is missing authorizedOrigins.
+ *
+ * @example
+ * // Example usage:
+ * testAuth(StackExchangeReputation, { items: [{ reputation: 8 }] })
+ */
+async function testAuth(serviceClass, dummyResponse) {
+  if (!(serviceClass.prototype instanceof BaseService)) {
+    throw new TypeError(
+      'Invalid serviceClass: Must be an instance of BaseService.',
+    )
+  }
+
+  cleanUpNockAfterEach()
+
+  const config = { private: { stackapps_api_key: 'fake-key' } }
+  const exampleInvokeParams = getBadgeExampleCall(serviceClass)
+  const authOrigin = serviceClass.auth.authorizedOrigins[0]
+
+  if (!authOrigin) {
+    throw new TypeError(`Missing authorizedOrigins for ${serviceClass.name}.`)
+  }
+
+  const scope = nock(authOrigin)
+    .get(/.*/)
+    .query(queryObject => queryObject.key === 'fake-key')
+    .reply(200, dummyResponse)
+  expect(
+    await serviceClass.invoke(defaultContext, config, exampleInvokeParams),
+  ).to.not.have.property('isError')
+
+  scope.done()
+}
+
 const defaultContext = { requestFetcher: fetch }
 
-export { cleanUpNockAfterEach, noToken, defaultContext }
+export {
+  cleanUpNockAfterEach,
+  noToken,
+  getBadgeExampleCall,
+  testAuth,
+  defaultContext,
+}