@tvkitchen/countertop/src/classes/__tests__/CountertopStream.unit.test.js

The entry point for developers who want to set up a TV Kitchen.

import assert from 'assert'
import CountertopStream from '../CountertopStream'
import CountertopStation from '../CountertopStation'
import {
	generateMockAppliance,
} from '../../tools/utils/jest'

describe('CountertopStream #unit', () => {
	describe('constructor', () => {
		it('Should not require tributaries for all inputs', () => {
			const Appliance = generateMockAppliance({
				inputTypes: ['bar'],
				outputTypes: [],
			})
			const station = new CountertopStation(Appliance)
			const stream = new CountertopStream(station)
			expect(stream.mouth).toBe(station)
			expect(stream.source).toBe(null)
		})

		it('Should throw an error when passed irrelevant tributaries', () => {
			const ApplianceA = generateMockAppliance({
				inputTypes: [],
				outputTypes: ['foo'],
			})
			const ApplianceB = generateMockAppliance({
				inputTypes: ['bar'],
				outputTypes: ['baz'],
			})
			const stationA = new CountertopStation(ApplianceA)
			const stationB = new CountertopStation(ApplianceB)
			const streamA = new CountertopStream(stationA)
			expect(() => new CountertopStream(
				stationB,
				new Map([['foo', streamA]]),
			)).toThrow(assert.AssertionError)
		})
	})

	describe('getSource', () => {
		it('Should return the core station if it is a source station', () => {
			const Appliance = generateMockAppliance({
				inputTypes: [],
				outputTypes: [],
			})
			const station = new CountertopStation(Appliance)
			const stream = new CountertopStream(station)
			expect(stream.getSource()).toBe(station)
		})

		it('Should return the source station', () => {
			const ApplianceA = generateMockAppliance({
				inputTypes: [],
				outputTypes: ['foo'],
			})
			const ApplianceB = generateMockAppliance({
				inputTypes: ['foo'],
				outputTypes: ['bar'],
			})
			const stationA = new CountertopStation(ApplianceA)
			const stationB = new CountertopStation(ApplianceB)
			const streamA = new CountertopStream(stationA)
			const streamB = new CountertopStream(
				stationB,
				new Map([['foo', streamA]]),
			)
			expect(streamB.getSource()).toBe(stationA)
		})
	})

	describe('getMouth', () => {
		it('Should return the core station', () => {
			const Appliance = generateMockAppliance({
				inputTypes: [],
				outputTypes: [],
			})
			const station = new CountertopStation(Appliance)
			const stream = new CountertopStream(station)
			expect(stream.getMouth()).toBe(station)
		})
	})

	describe('getTributaryMap', () => {
		it('Should return a tributary map', () => {
			const ApplianceA = generateMockAppliance({
				inputTypes: [],
				outputTypes: ['foo'],
			})
			const ApplianceB = generateMockAppliance({
				inputTypes: ['foo'],
				outputTypes: ['bar'],
			})
			const stationA = new CountertopStation(ApplianceA)
			const stationB = new CountertopStation(ApplianceB)
			const streamA = new CountertopStream(stationA)
			const streamB = new CountertopStream(
				stationB,
				new Map([['foo', streamA]]),
			)
			const tributaryMap = streamB.getTributaryMap()
			expect(tributaryMap.get('foo')).toBe(streamA)
		})
	})

	describe('getTributaryArray', () => {
		it('Should return a tributary map', () => {
			const ApplianceA = generateMockAppliance({
				inputTypes: [],
				outputTypes: ['foo'],
			})
			const ApplianceB = generateMockAppliance({
				inputTypes: ['foo'],
				outputTypes: ['bar'],
			})
			const stationA = new CountertopStation(ApplianceA)
			const stationB = new CountertopStation(ApplianceB)
			const streamA = new CountertopStream(stationA)
			const streamB = new CountertopStream(
				stationB,
				new Map([['foo', streamA]]),
			)
			const tributaryArray = streamB.getTributaryArray()
			expect(tributaryArray).toContain(streamA)
		})
	})

	describe('getLength', () => {
		it('Should have length 1 if it is a source stream', () => {
			const Appliance = generateMockAppliance({
				inputTypes: [],
				outputTypes: [],
			})
			const station = new CountertopStation(Appliance)
			const stream = new CountertopStream(station)
			expect(stream.getLength()).toBe(1)
		})

		it('Should have the correct length', () => {
			const ApplianceA = generateMockAppliance({
				inputTypes: [],
				outputTypes: ['foo'],
			})
			const ApplianceB = generateMockAppliance({
				inputTypes: ['foo'],
				outputTypes: ['bar'],
			})
			const stationA = new CountertopStation(ApplianceA)
			const stationB = new CountertopStation(ApplianceB)
			const streamA = new CountertopStream(stationA)
			const streamB = new CountertopStream(
				stationB,
				new Map([['foo', streamA]]),
			)
			expect(streamB.getLength()).toBe(2)
		})
	})

	describe('includesStation', () => {
		it('Should return true if a station is in the stream', () => {
			const ApplianceA = generateMockAppliance({
				inputTypes: [],
				outputTypes: ['foo'],
			})
			const ApplianceB = generateMockAppliance({
				inputTypes: ['foo'],
				outputTypes: ['bar'],
			})
			const stationA = new CountertopStation(ApplianceA)
			const stationB = new CountertopStation(ApplianceB)
			const streamA = new CountertopStream(stationA)
			const streamB = new CountertopStream(
				stationB,
				new Map([['foo', streamA]]),
			)
			expect(streamB.includesStation(stationA)).toBe(true)
			expect(streamB.includesStation(stationB)).toBe(true)
		})

		it('Should return false if a station is not in the stream', () => {
			const ApplianceA = generateMockAppliance({
				inputTypes: [],
				outputTypes: ['foo'],
			})
			const ApplianceB = generateMockAppliance({
				inputTypes: ['foo'],
				outputTypes: ['bar'],
			})
			const stationA = new CountertopStation(ApplianceA)
			const stationB = new CountertopStation(ApplianceB)
			const streamA = new CountertopStream(stationA)
			expect(streamA.includesStation(stationB)).toBe(false)
		})
	})

	describe('getOutputTypes', () => {
		it('Should return the output types of the mouth station', () => {
			const ApplianceA = generateMockAppliance({
				inputTypes: [],
				outputTypes: ['foo'],
			})
			const ApplianceB = generateMockAppliance({
				inputTypes: ['foo'],
				outputTypes: ['bar', 'baz'],
			})
			const stationA = new CountertopStation(ApplianceA)
			const stationB = new CountertopStation(ApplianceB)
			const streamA = new CountertopStream(stationA)
			const streamB = new CountertopStream(
				stationB,
				new Map([['foo', streamA]]),
			)
			expect(streamB.getOutputTypes(stationA)).toEqual(['bar', 'baz'])
		})
	})
})