@1mill/cloudevents 4.0.0 → 4.1.0

package/src/tests/time.test.js

@@ -0,0 +1,36 @@
+import chai, { expect } from 'chai'
+import chaiIso8601 from 'chai-iso8601'
+import { Cloudevent } from '../index.js'
+import { useFakeTimers } from 'sinon'
+
+chai.use(chaiIso8601())
+
+describe('cloudevent#time', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	it('returns a string', () => {
+		const { time } = new Cloudevent(params)
+		expect(time).to.be.a('string')
+	})
+
+	it('returns the current time formatted in ISO8601', () => {
+		const clock = useFakeTimers()
+
+		clock.tick(987654321) // * Jump into the future
+		const expected = new Date().toISOString()
+		const { time } = new Cloudevent(params)
+
+		clock.tick(123456789) // * Jump into the future
+		expect(time).to.be.iso8601('eq', expected)
+
+		clock.restore()
+	})
+})

package/src/tests/type.test.js

@@ -0,0 +1,39 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#type', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when a #type value is not input', () => {
+		it('throws the proper error', () => {
+			const expected = 'Cloudevent "type" must be of type STRING'
+			params.type = null
+			expect(() => new Cloudevent(params)).to.throw(expected)
+		})
+	})
+
+	describe('when a #type value is input', () => {
+		describe('when the input value is not a string', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "type" must be of type STRING'
+				params.type = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is a string', () => {
+			it('returns the input value', () => {
+				const { type } = new Cloudevent(params)
+				expect(type).to.eq(params.type)
+			})
+		})
+	})
+})

package/src/unit.test.js

@@ -0,0 +1,92 @@
+import chai, { expect } from 'chai'
+import chaiIso8601 from 'chai-iso8601'
+import chaiSubset from 'chai-subset'
+import { Cloudevent } from '../dist/index.cjs'
+import { useFakeTimers } from 'sinon'
+
+chai.use(chaiIso8601)
+chai.use(chaiSubset)
+
+describe('new Cloudevent', () => {
+	let clock
+
+	beforeEach(() => {
+		clock = useFakeTimers()
+	})
+
+	afterEach(() => {
+		clock.restore()
+	})
+
+	describe('when the cloudevent is not enriched', () => {
+		it('returns the expected cloudevent', () => {
+			clock.tick(987654321) // * Jump into the future
+
+			const data = JSON.stringify({ some: 'data' })
+			const source = 'some-source'
+			const time = new Date().toISOString()
+			const type = 'some-type'
+
+			const cloudevent = new Cloudevent({ data, source, type })
+
+			clock.tick(123456789) // * Jump into the future
+
+			expect(cloudevent).to.containSubset({
+				data,
+				datacontenttype: 'application/json',
+				originsource: source,
+				origintime: time,
+				origintype: type,
+				source,
+				specversion: '1.0',
+				time,
+				type,
+			})
+		})
+	})
+
+	describe('when the cloudevent is enriched', () => {
+		it('returns the expected cloudevent', () => {
+			clock.tick(987654321) // * Jump into the future
+
+			const originCloudevent = new Cloudevent({
+				data: JSON.stringify({ some: 'data' }),
+				source: 'some-origin-source',
+				type: 'some-origin-type',
+			})
+
+			clock.tick(123456789) // * Jump into the future
+
+			const data = undefined
+			const datacontenttype = undefined
+			const source = 'some-enrichment-source'
+			const time = new Date().toISOString()
+			const type = 'some-enrichment-type'
+
+			const cloudevent = new Cloudevent({
+				...originCloudevent,
+				data,
+				datacontenttype,
+				source,
+				type,
+
+			})
+
+			clock.tick(987654321) // * Jump into the future
+			expect(cloudevent).to.containSubset({
+				data,
+				datacontenttype: undefined,
+				dataschema: undefined,
+				originid: originCloudevent.id,
+				originsource: originCloudevent.source,
+				origintime: originCloudevent.time,
+				origintype: originCloudevent.type,
+				source,
+				specversion: '1.0',
+				subject: undefined,
+				time,
+				type,
+			})
+		})
+	})
+})

package/src/utils/fetchNodeEnv/index.js

@@ -0,0 +1,4 @@
+export const fetchNodeEnv = (name, fallbackValue) => {
+	if (typeof process === 'undefined') { return }
+	return process.env[name] || fallbackValue
+}

package/src/utils/fetchNodeEnv/unit.test.js

@@ -0,0 +1,55 @@
+import { createSandbox } from 'sinon'
+import { expect } from 'chai'
+import { fetchNodeEnv } from './index.js'
+
+describe('fetchNodeEnv', () => {
+	const name = 'SOME_NAME'
+	const sandbox = createSandbox()
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	describe('when the node global.process is not defined', () => {
+		it('returns undefined', () => {
+			sandbox.stub(global, 'process').value(undefined)
+			const result = fetchNodeEnv(name)
+			expect(result).to.be.undefined
+		})
+	})
+
+	describe('when the node global.process is defined', () => {
+		describe('when the input name does not exist as an environmental variable', () => {
+			describe('when a fallback value is not input', () => {
+				it ('returns undefined', () => {
+					sandbox.stub(process, 'env').value({})
+					const result = fetchNodeEnv(name)
+					expect(result).to.be.undefined
+				})
+			})
+
+			describe('when a fallback value is input', () => {
+				it ('returns the input fallback value', () => {
+					const fallbackValue = 'some-fallback-value'
+
+					sandbox.stub(process, 'env').value({})
+
+					const result = fetchNodeEnv(name, fallbackValue)
+					expect(result).to.eq(fallbackValue)
+				})
+			})
+		})
+
+		describe('when the input name exists as an environmental variable', () => {
+			it('returns the proper environmental variable', () => {
+				const expected = 'some-value'
+
+				const env = { [name]: expected }
+				sandbox.stub(process, 'env').value(env)
+
+				const result = fetchNodeEnv(name, 'some-fallback-value')
+				expect(result).to.eq(expected)
+			})
+		})
+	})
+})

package/src/utils/setAttribute/index.js

@@ -0,0 +1,7 @@
+export const setAttribute = ({ cloudevent, name, types = [], value }) => {
+	if (types.length > 0 && !types.includes(typeof value)) {
+		const message = `Cloudevent "${name}" must be of type ${types.map(s => s.toUpperCase()).sort().join(' or ')}.`
+		throw new Error(message)
+	}
+	cloudevent[name] = value
+}

package/src/utils/setAttribute/unit.test.js

@@ -0,0 +1,43 @@
+import { setAttribute } from './index.js'
+import { expect } from 'chai'
+
+describe('setAttribute', () => {
+	const name = 'some-name'
+	let cloudevent
+
+	beforeEach(() => {
+		cloudevent = {}
+	})
+
+	describe('when #types is not empty', () => {
+		describe('when the type of #value is not in #types', () => {
+			it('throws the proper error', () => {
+				const types = ['undefined', 'string']
+				const value = 1234
+
+				const expected = `Cloudevent "${name}" must be of type STRING or UNDEFINED`
+
+				expect(() => setAttribute({ cloudevent, name, types, value })).to.throw(expected)
+			})
+		})
+
+		describe('when the type of #value is in #types', () => {
+			[1234, undefined].forEach(value => {
+				it('sets cloudevent[#name] to the input #value', () => {
+					const types = ['number', 'undefined']
+					setAttribute({ cloudevent, name, types, value })
+					expect(cloudevent[name]).to.eq(value)
+				})
+			})
+		})
+	})
+
+	describe('when #types is empty', () => {
+		[1234, '1234', undefined].forEach(value => {
+			it('sets cloudevent[#name] to the input #value', () => {
+				setAttribute({ cloudevent, name, value })
+				expect(cloudevent[name]).to.eq(value)
+			})
+		})
+	})
+})