test: adds tests and docstrings for core-utils misc functions

.changeset/eighty-comics-push.md

+---
+'@eth-optimism/core-utils': patch
+---
+
+Added tests and docstrings to misc functions

packages/core-utils/src/common/misc.ts

@@ -11,7 +11,12 @@ export const sleep = async (ms: number): Promise<void> => {
   })
 }
 
-// Returns a copy of an object
+/**
+ * Returns a clone of the object.
+ *
+ * @param obj Object to clone.
+ * @returns Clone of the object.
+ */
 export const clone = (obj: any): any => {
   if (typeof obj === 'undefined') {
     throw new Error(`Trying to clone undefined object`)
@@ -33,6 +38,13 @@ export const reqenv = (name: string): string => {
   return value
 }
 
+/**
+ * Loads a variable from the environment and returns a fallback if not found.
+ *
+ * @param name Name of the variable to load.
+ * @param [fallback] Optional value to be returned as fallback.
+ * @returns Value of the variable as a string, fallback or undefined.
+ */
 export const getenv = (name: string, fallback?: string): string | undefined => {
   return process.env[name] || fallback
 }

packages/core-utils/test/misc.spec.ts

 /* Imports: Internal */
 import { expect } from './setup'
-import { sleep } from '../src'
+import { sleep, clone, reqenv, getenv } from '../src'
 
 describe('sleep', async () => {
   it('should return wait input amount of ms', async () => {
@@ -10,3 +10,83 @@ describe('sleep', async () => {
     expect(startTime + 1000 <= endTime).to.deep.equal(true)
   })
 })
+
+describe('clone', async () => {
+  it('should return a cloned object', async () => {
+    const exampleObject = { example: 'Example' }
+    const clonedObject = clone(exampleObject)
+    expect(clonedObject).to.not.equal(exampleObject)
+    expect(JSON.stringify(clonedObject)).to.equal(JSON.stringify(exampleObject))
+  })
+})
+
+describe('reqenv', async () => {
+  let cachedEnvironment
+  const temporaryEnvironmentKey = 'testVariable'
+  const temporaryEnvironment = {
+    [temporaryEnvironmentKey]: 'This is an environment variable',
+  }
+
+  before(() => {
+    cachedEnvironment = process.env
+    process.env = temporaryEnvironment
+  })
+
+  it('should return an existent environment variable', async () => {
+    const requiredEnvironmentValue = reqenv(temporaryEnvironmentKey)
+    expect(requiredEnvironmentValue).to.equal(
+      temporaryEnvironment[temporaryEnvironmentKey]
+    )
+  })
+
+  it('should throw an error trying to return a variable that does not exist', async () => {
+    const undeclaredVariableName = 'undeclaredVariable'
+    const failedReqenv = () => reqenv(undeclaredVariableName)
+    expect(failedReqenv).to.throw()
+  })
+
+  after(() => {
+    process.env = cachedEnvironment
+  })
+})
+
+describe('getenv', async () => {
+  let cachedEnvironment
+  const temporaryEnvironmentKey = 'testVariable'
+  const temporaryEnvironment = {
+    [temporaryEnvironmentKey]: 'This is an environment variable',
+  }
+  const fallback = 'fallback'
+
+  before(() => {
+    cachedEnvironment = process.env
+    process.env = temporaryEnvironment
+  })
+
+  it('should return an existent environment variable', async () => {
+    const environmentVariable = getenv(temporaryEnvironmentKey)
+    expect(environmentVariable).to.equal(
+      temporaryEnvironment[temporaryEnvironmentKey]
+    )
+  })
+
+  it('should return an existent environment variable even if fallback is passed', async () => {
+    const environmentVariable = getenv(temporaryEnvironmentKey, fallback)
+    expect(environmentVariable).to.equal(
+      temporaryEnvironment[temporaryEnvironmentKey]
+    )
+  })
+
+  it('should return fallback if variable is not defined', async () => {
+    const undeclaredVariableName = 'undeclaredVariable'
+    expect(getenv(undeclaredVariableName, fallback)).to.equal(fallback)
+  })
+
+  it('should return undefined if no fallback is passed and variable is not defined', async () => {
+    expect(getenv('undeclaredVariable')).to.be.undefined
+  })
+
+  after(() => {
+    process.env = cachedEnvironment
+  })
+})