735 lines
29 KiB
JavaScript
735 lines
29 KiB
JavaScript
import chai from 'chai'
|
|
import { Design } from '../src/index.mjs'
|
|
|
|
const expect = chai.expect
|
|
|
|
describe('Pattern', () => {
|
|
describe('Pattern.constructor()', () => {
|
|
it('Pattern constructor should return pattern object', () => {
|
|
const Pattern = new Design()
|
|
const pattern = new Pattern()
|
|
expect(typeof pattern).to.equal('object')
|
|
})
|
|
|
|
it('Pattern constructor should add enumerable properties', () => {
|
|
const Pattern = new Design()
|
|
const pattern = new Pattern()
|
|
expect(Array.isArray(pattern.settings)).to.equal(true)
|
|
expect(Array.isArray(pattern.stores)).to.equal(true)
|
|
expect(typeof pattern.config).to.equal('object')
|
|
expect(typeof pattern.store).to.equal('undefined')
|
|
expect(Object.keys(pattern).length).to.equal(4)
|
|
})
|
|
|
|
it('Pattern constructor should add non-enumerable properties', () => {
|
|
const Pattern = new Design()
|
|
const pattern = new Pattern()
|
|
expect(typeof pattern.plugins).to.equal('object')
|
|
expect(typeof pattern.autoLayout).to.equal('object')
|
|
expect(typeof pattern.hooks).to.equal('object')
|
|
expect(typeof pattern.Point).to.equal('function')
|
|
expect(typeof pattern.Path).to.equal('function')
|
|
expect(typeof pattern.Snippet).to.equal('function')
|
|
expect(typeof pattern.Attributes).to.equal('function')
|
|
expect(typeof pattern.macros).to.equal('object')
|
|
expect(typeof pattern.__parts).to.equal('object')
|
|
expect(typeof pattern.__inject).to.equal('object')
|
|
expect(typeof pattern.__dependencies).to.equal('object')
|
|
expect(typeof pattern.__resolvedDependencies).to.equal('object')
|
|
expect(typeof pattern.__hide).to.equal('object')
|
|
expect(Array.isArray(pattern.__draftOrder)).to.equal(true)
|
|
expect(pattern.width).to.equal(0)
|
|
expect(pattern.height).to.equal(0)
|
|
expect(pattern.is).to.equal('')
|
|
})
|
|
|
|
it('Pattern constructor should add default settings', () => {
|
|
const Pattern = new Design()
|
|
const pattern = new Pattern()
|
|
const dflts = {
|
|
complete: true,
|
|
idPrefix: 'fs-',
|
|
locale: 'en',
|
|
units: 'metric',
|
|
margin: 2,
|
|
scale: 1,
|
|
layout: true,
|
|
debug: false,
|
|
options: {},
|
|
absoluteOptions: {},
|
|
}
|
|
for (const [key, value] of Object.entries(dflts)) {
|
|
if (typeof value === 'object') expect(Object.keys(value).length).to.equal(0)
|
|
else expect(pattern.settings[0][key]).to.equal(value)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('Pattern.init()', () => {
|
|
const partA = {
|
|
name: 'test.partA',
|
|
measurements: ['head', 'knee'],
|
|
optionalMeasurements: ['chest', 'waist'],
|
|
options: {
|
|
optA: { pct: 40, min: 20, max: 80 },
|
|
},
|
|
draft: () => {},
|
|
}
|
|
const partB = {
|
|
name: 'test.partB',
|
|
measurements: ['head', 'knee'],
|
|
optionalMeasurements: ['knee'],
|
|
after: partA,
|
|
plugins: [
|
|
{
|
|
name: 'testPlugin',
|
|
hooks: {
|
|
preRender: () => {},
|
|
},
|
|
},
|
|
],
|
|
options: {
|
|
optB: { deg: 40, min: 20, max: 80 },
|
|
},
|
|
draft: () => {},
|
|
}
|
|
const partC = {
|
|
name: 'test.partC',
|
|
measurements: ['head', 'knee'],
|
|
optionalMeasurements: ['knee'],
|
|
from: partB,
|
|
options: {
|
|
optC: { pct: 20, min: 10, max: 30 },
|
|
},
|
|
draft: () => {},
|
|
}
|
|
|
|
const Pattern = new Design({
|
|
data: {
|
|
name: 'test',
|
|
version: '1.2.3',
|
|
},
|
|
parts: [partC],
|
|
})
|
|
const pattern = new Pattern()
|
|
pattern.init()
|
|
|
|
it('Pattern.init() should resolve all measurements', () => {
|
|
expect(
|
|
[...pattern.config.measurements, ...pattern.config.optionalMeasurements].length
|
|
).to.equal(4)
|
|
})
|
|
|
|
it('Pattern.init() should resolve required measurements', () => {
|
|
expect(pattern.config.measurements.length).to.equal(2)
|
|
expect(pattern.config.measurements[0]).to.equal('head')
|
|
expect(pattern.config.measurements[1]).to.equal('knee')
|
|
})
|
|
|
|
it('Pattern.init() should resolve optional measurements', () => {
|
|
expect(pattern.config.optionalMeasurements.length).to.equal(2)
|
|
expect(pattern.config.optionalMeasurements[0]).to.equal('chest')
|
|
expect(pattern.config.optionalMeasurements[1]).to.equal('waist')
|
|
})
|
|
|
|
it('Pattern.init() should resolve options', () => {
|
|
expect(Object.keys(pattern.config.options).length).to.equal(3)
|
|
for (const [key, value] of Object.entries(partA.options.optA)) {
|
|
expect(pattern.config.options.optA[key]).to.equal(value)
|
|
}
|
|
for (const [key, value] of Object.entries(partB.options.optB)) {
|
|
expect(pattern.config.options.optB[key]).to.equal(value)
|
|
}
|
|
for (const [key, value] of Object.entries(partC.options.optC)) {
|
|
expect(pattern.config.options.optC[key]).to.equal(value)
|
|
}
|
|
})
|
|
|
|
it('Pattern.init() should resolve parts', () => {
|
|
expect(pattern.config.parts.length).to.equal(3)
|
|
})
|
|
|
|
it('Pattern.init() should resolve plugins', () => {
|
|
expect(pattern.config.plugins.length).to.equal(1)
|
|
})
|
|
|
|
it('Pattern.init() should set config data in the store', () => {
|
|
expect(pattern.stores[0].get('data.name')).to.equal('test')
|
|
expect(pattern.stores[0].get('data.version')).to.equal('1.2.3')
|
|
})
|
|
|
|
it('Pattern.init() should resolve dependencies', () => {
|
|
expect(typeof pattern.config.resolvedDependencies).to.equal('object')
|
|
expect(Array.isArray(pattern.config.resolvedDependencies['test.partA'])).to.equal(true)
|
|
expect(pattern.config.resolvedDependencies['test.partA'].length).to.equal(0)
|
|
expect(Array.isArray(pattern.config.resolvedDependencies['test.partB'])).to.equal(true)
|
|
expect(pattern.config.resolvedDependencies['test.partB'].length).to.equal(1)
|
|
expect(pattern.config.resolvedDependencies['test.partB'][0]).to.equal('test.partA')
|
|
expect(Array.isArray(pattern.config.resolvedDependencies['test.partC'])).to.equal(true)
|
|
expect(pattern.config.resolvedDependencies['test.partC'].length).to.equal(2)
|
|
expect(
|
|
pattern.config.resolvedDependencies['test.partC'].indexOf('test.partA') !== -1
|
|
).to.equal(true)
|
|
expect(
|
|
pattern.config.resolvedDependencies['test.partC'].indexOf('test.partB') !== -1
|
|
).to.equal(true)
|
|
})
|
|
|
|
it('Pattern.init() should resolve the draft order', () => {
|
|
expect(Array.isArray(pattern.config.draftOrder)).to.equal(true)
|
|
expect(pattern.config.draftOrder[0]).to.equal('test.partA')
|
|
expect(pattern.config.draftOrder[1]).to.equal('test.partB')
|
|
expect(pattern.config.draftOrder[2]).to.equal('test.partC')
|
|
})
|
|
|
|
// I am aware this does too much for one unit test, but this is to simplify TDD
|
|
// we can split it up later
|
|
it('Pattern.init() should resolve nested injections', () => {
|
|
const partA = {
|
|
name: 'partA',
|
|
options: { optionA: { bool: true } },
|
|
measurements: ['measieA'],
|
|
optionalMeasurements: ['optmeasieA'],
|
|
draft: ({ points, Point, paths, Path, part }) => {
|
|
points.a1 = new Point(1, 1)
|
|
points.a2 = new Point(11, 11)
|
|
paths.a = new Path().move(points.a1).line(points.a2)
|
|
|
|
return part
|
|
},
|
|
}
|
|
const partB = {
|
|
name: 'partB',
|
|
from: partA,
|
|
options: { optionB: { pct: 12, min: 2, max: 20 } },
|
|
measurements: ['measieB'],
|
|
optionalMeasurements: ['optmeasieB', 'measieA'],
|
|
draft: ({ points, Point, paths, Path, part }) => {
|
|
points.b1 = new Point(2, 2)
|
|
points.b2 = new Point(22, 22)
|
|
paths.b = new Path().move(points.b1).line(points.b2)
|
|
return part
|
|
},
|
|
}
|
|
const partC = {
|
|
name: 'partC',
|
|
from: partB,
|
|
options: { optionC: { deg: 5, min: 0, max: 15 } },
|
|
measurements: ['measieC'],
|
|
optionalMeasurements: ['optmeasieC', 'measieA'],
|
|
draft: ({ points, Point, paths, Path, part }) => {
|
|
points.c1 = new Point(3, 3)
|
|
points.c2 = new Point(33, 33)
|
|
paths.c = new Path().move(points.c1).line(points.c2)
|
|
return part
|
|
},
|
|
}
|
|
const partR = {
|
|
// R for runtime, which is when this wil be attached
|
|
name: 'partR',
|
|
from: partA,
|
|
after: partC,
|
|
options: { optionR: { dflt: 'red', list: ['red', 'green', 'blue'] } },
|
|
measurements: ['measieR'],
|
|
optionalMeasurements: ['optmeasieR', 'measieA'],
|
|
draft: ({ points, Point, paths, Path, part }) => {
|
|
points.r1 = new Point(4, 4)
|
|
points.r2 = new Point(44, 44)
|
|
paths.r = new Path().move(points.r1).line(points.r2)
|
|
return part
|
|
},
|
|
}
|
|
|
|
const design = new Design({ parts: [partC] })
|
|
const pattern = new design().addPart(partR).draft()
|
|
// Measurements
|
|
expect(pattern.config.measurements.length).to.equal(4)
|
|
expect(pattern.config.measurements.indexOf('measieA') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieB') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieC') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieR') === -1).to.equal(false)
|
|
// Optional measurements
|
|
expect(pattern.config.optionalMeasurements.length).to.equal(4)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieA') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieB') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieC') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieR') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('measieA') === -1).to.equal(true)
|
|
// Options
|
|
expect(pattern.config.options.optionA.bool).to.equal(true)
|
|
expect(pattern.config.options.optionB.pct).to.equal(12)
|
|
expect(pattern.config.options.optionB.min).to.equal(2)
|
|
expect(pattern.config.options.optionB.max).to.equal(20)
|
|
expect(pattern.config.options.optionC.deg).to.equal(5)
|
|
expect(pattern.config.options.optionC.min).to.equal(0)
|
|
expect(pattern.config.options.optionC.max).to.equal(15)
|
|
expect(pattern.config.options.optionR.dflt).to.equal('red')
|
|
expect(pattern.config.options.optionR.list[0]).to.equal('red')
|
|
expect(pattern.config.options.optionR.list[1]).to.equal('green')
|
|
expect(pattern.config.options.optionR.list[2]).to.equal('blue')
|
|
// Dependencies
|
|
expect(pattern.__dependencies.partB[0]).to.equal('partA')
|
|
expect(pattern.__dependencies.partC[0]).to.equal('partB')
|
|
expect(pattern.__dependencies.partR[0]).to.equal('partC')
|
|
expect(pattern.__dependencies.partR[1]).to.equal('partA')
|
|
// Inject
|
|
expect(pattern.__inject.partB).to.equal('partA')
|
|
expect(pattern.__inject.partC).to.equal('partB')
|
|
expect(pattern.__inject.partR).to.equal('partA')
|
|
// Draft order
|
|
expect(pattern.config.draftOrder[0]).to.equal('partA')
|
|
expect(pattern.config.draftOrder[1]).to.equal('partB')
|
|
expect(pattern.config.draftOrder[2]).to.equal('partC')
|
|
expect(pattern.config.draftOrder[3]).to.equal('partR')
|
|
// Points
|
|
expect(pattern.parts[0].partA.points.a1.x).to.equal(1)
|
|
expect(pattern.parts[0].partA.points.a1.y).to.equal(1)
|
|
expect(pattern.parts[0].partA.points.a2.x).to.equal(11)
|
|
expect(pattern.parts[0].partA.points.a2.y).to.equal(11)
|
|
expect(pattern.parts[0].partB.points.b1.x).to.equal(2)
|
|
expect(pattern.parts[0].partB.points.b1.y).to.equal(2)
|
|
expect(pattern.parts[0].partB.points.b2.x).to.equal(22)
|
|
expect(pattern.parts[0].partB.points.b2.y).to.equal(22)
|
|
expect(pattern.parts[0].partC.points.c1.x).to.equal(3)
|
|
expect(pattern.parts[0].partC.points.c1.y).to.equal(3)
|
|
expect(pattern.parts[0].partC.points.c2.x).to.equal(33)
|
|
expect(pattern.parts[0].partC.points.c2.y).to.equal(33)
|
|
expect(pattern.parts[0].partR.points.r1.x).to.equal(4)
|
|
expect(pattern.parts[0].partR.points.r1.y).to.equal(4)
|
|
expect(pattern.parts[0].partR.points.r2.x).to.equal(44)
|
|
expect(pattern.parts[0].partR.points.r2.y).to.equal(44)
|
|
// Paths in partA
|
|
expect(pattern.parts[0].partA.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts[0].partA.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts[0].partA.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts[0].partA.paths.a.ops[1].to.y).to.equal(11)
|
|
// Paths in partB
|
|
expect(pattern.parts[0].partB.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts[0].partB.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts[0].partB.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts[0].partB.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts[0].partB.paths.b.ops[0].to.x).to.equal(2)
|
|
expect(pattern.parts[0].partB.paths.b.ops[0].to.y).to.equal(2)
|
|
expect(pattern.parts[0].partB.paths.b.ops[1].to.x).to.equal(22)
|
|
expect(pattern.parts[0].partB.paths.b.ops[1].to.y).to.equal(22)
|
|
// Paths in partC
|
|
expect(pattern.parts[0].partC.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts[0].partC.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts[0].partC.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts[0].partC.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts[0].partC.paths.b.ops[0].to.x).to.equal(2)
|
|
expect(pattern.parts[0].partC.paths.b.ops[0].to.y).to.equal(2)
|
|
expect(pattern.parts[0].partC.paths.b.ops[1].to.x).to.equal(22)
|
|
expect(pattern.parts[0].partC.paths.b.ops[1].to.y).to.equal(22)
|
|
expect(pattern.parts[0].partC.paths.c.ops[0].to.x).to.equal(3)
|
|
expect(pattern.parts[0].partC.paths.c.ops[0].to.y).to.equal(3)
|
|
expect(pattern.parts[0].partC.paths.c.ops[1].to.x).to.equal(33)
|
|
expect(pattern.parts[0].partC.paths.c.ops[1].to.y).to.equal(33)
|
|
// Paths in partR
|
|
expect(pattern.parts[0].partC.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts[0].partC.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts[0].partC.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts[0].partC.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts[0].partR.paths.r.ops[0].to.x).to.equal(4)
|
|
expect(pattern.parts[0].partR.paths.r.ops[0].to.y).to.equal(4)
|
|
expect(pattern.parts[0].partR.paths.r.ops[1].to.x).to.equal(44)
|
|
expect(pattern.parts[0].partR.paths.r.ops[1].to.y).to.equal(44)
|
|
})
|
|
|
|
it('Pattern.init() should resolve nested dependencies', () => {
|
|
const partA = {
|
|
name: 'partA',
|
|
options: { optionA: { bool: true } },
|
|
measurements: ['measieA'],
|
|
optionalMeasurements: ['optmeasieA'],
|
|
draft: ({ points, Point, paths, Path, part }) => {
|
|
points.a1 = new Point(1, 1)
|
|
points.a2 = new Point(11, 11)
|
|
paths.a = new Path().move(points.a1).line(points.a2)
|
|
return part
|
|
},
|
|
}
|
|
const partB = {
|
|
name: 'partB',
|
|
from: partA,
|
|
options: { optionB: { pct: 12, min: 2, max: 20 } },
|
|
measurements: ['measieB'],
|
|
optionalMeasurements: ['optmeasieB', 'measieA'],
|
|
draft: ({ points, Point, paths, Path, part }) => {
|
|
points.b1 = new Point(2, 2)
|
|
points.b2 = new Point(22, 22)
|
|
paths.b = new Path().move(points.b1).line(points.b2)
|
|
return part
|
|
},
|
|
}
|
|
const partC = {
|
|
name: 'partC',
|
|
from: partB,
|
|
options: { optionC: { deg: 5, min: 0, max: 15 } },
|
|
measurements: ['measieC'],
|
|
optionalMeasurements: ['optmeasieC', 'measieA'],
|
|
draft: ({ points, Point, paths, Path, part }) => {
|
|
points.c1 = new Point(3, 3)
|
|
points.c2 = new Point(33, 33)
|
|
paths.c = new Path().move(points.c1).line(points.c2)
|
|
return part
|
|
},
|
|
}
|
|
const partD = {
|
|
name: 'partD',
|
|
after: partC,
|
|
options: { optionD: { dflt: 'red', list: ['red', 'green', 'blue'] } },
|
|
measurements: ['measieD'],
|
|
optionalMeasurements: ['optmeasieD', 'measieA'],
|
|
draft: ({ points, Point, paths, Path, part }) => {
|
|
points.d1 = new Point(4, 4)
|
|
points.d2 = new Point(44, 44)
|
|
paths.d = new Path().move(points.d1).line(points.d2)
|
|
return part
|
|
},
|
|
}
|
|
const design = new Design({ parts: [partD] })
|
|
const pattern = new design().draft()
|
|
// Measurements
|
|
expect(pattern.config.measurements.length).to.equal(4)
|
|
expect(pattern.config.measurements.indexOf('measieA') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieB') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieC') === -1).to.equal(false)
|
|
expect(pattern.config.measurements.indexOf('measieD') === -1).to.equal(false)
|
|
// Optional measurements
|
|
expect(pattern.config.optionalMeasurements.length).to.equal(4)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieA') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieB') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieC') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('optmeasieD') === -1).to.equal(false)
|
|
expect(pattern.config.optionalMeasurements.indexOf('measieA') === -1).to.equal(true)
|
|
// Options
|
|
expect(pattern.config.options.optionA.bool).to.equal(true)
|
|
expect(pattern.config.options.optionB.pct).to.equal(12)
|
|
expect(pattern.config.options.optionB.min).to.equal(2)
|
|
expect(pattern.config.options.optionB.max).to.equal(20)
|
|
expect(pattern.config.options.optionC.deg).to.equal(5)
|
|
expect(pattern.config.options.optionC.min).to.equal(0)
|
|
expect(pattern.config.options.optionC.max).to.equal(15)
|
|
expect(pattern.config.options.optionD.dflt).to.equal('red')
|
|
expect(pattern.config.options.optionD.list[0]).to.equal('red')
|
|
expect(pattern.config.options.optionD.list[1]).to.equal('green')
|
|
expect(pattern.config.options.optionD.list[2]).to.equal('blue')
|
|
// Dependencies
|
|
expect(pattern.__dependencies.partB[0]).to.equal('partA')
|
|
expect(pattern.__dependencies.partC[0]).to.equal('partB')
|
|
expect(pattern.__dependencies.partD[0]).to.equal('partC')
|
|
// Inject
|
|
expect(pattern.__inject.partB).to.equal('partA')
|
|
expect(pattern.__inject.partC).to.equal('partB')
|
|
// Draft order
|
|
expect(pattern.config.draftOrder[0]).to.equal('partA')
|
|
expect(pattern.config.draftOrder[1]).to.equal('partB')
|
|
expect(pattern.config.draftOrder[2]).to.equal('partC')
|
|
expect(pattern.config.draftOrder[3]).to.equal('partD')
|
|
// Points
|
|
expect(pattern.parts[0].partA.points.a1.x).to.equal(1)
|
|
expect(pattern.parts[0].partA.points.a1.y).to.equal(1)
|
|
expect(pattern.parts[0].partA.points.a2.x).to.equal(11)
|
|
expect(pattern.parts[0].partA.points.a2.y).to.equal(11)
|
|
expect(pattern.parts[0].partB.points.b1.x).to.equal(2)
|
|
expect(pattern.parts[0].partB.points.b1.y).to.equal(2)
|
|
expect(pattern.parts[0].partB.points.b2.x).to.equal(22)
|
|
expect(pattern.parts[0].partB.points.b2.y).to.equal(22)
|
|
expect(pattern.parts[0].partC.points.c1.x).to.equal(3)
|
|
expect(pattern.parts[0].partC.points.c1.y).to.equal(3)
|
|
expect(pattern.parts[0].partC.points.c2.x).to.equal(33)
|
|
expect(pattern.parts[0].partC.points.c2.y).to.equal(33)
|
|
expect(pattern.parts[0].partD.points.d1.x).to.equal(4)
|
|
expect(pattern.parts[0].partD.points.d1.y).to.equal(4)
|
|
expect(pattern.parts[0].partD.points.d2.x).to.equal(44)
|
|
expect(pattern.parts[0].partD.points.d2.y).to.equal(44)
|
|
// Paths in partA
|
|
expect(pattern.parts[0].partA.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts[0].partA.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts[0].partA.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts[0].partA.paths.a.ops[1].to.y).to.equal(11)
|
|
// Paths in partB
|
|
expect(pattern.parts[0].partB.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts[0].partB.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts[0].partB.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts[0].partB.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts[0].partB.paths.b.ops[0].to.x).to.equal(2)
|
|
expect(pattern.parts[0].partB.paths.b.ops[0].to.y).to.equal(2)
|
|
expect(pattern.parts[0].partB.paths.b.ops[1].to.x).to.equal(22)
|
|
expect(pattern.parts[0].partB.paths.b.ops[1].to.y).to.equal(22)
|
|
// Paths in partC
|
|
expect(pattern.parts[0].partC.paths.a.ops[0].to.x).to.equal(1)
|
|
expect(pattern.parts[0].partC.paths.a.ops[0].to.y).to.equal(1)
|
|
expect(pattern.parts[0].partC.paths.a.ops[1].to.x).to.equal(11)
|
|
expect(pattern.parts[0].partC.paths.a.ops[1].to.y).to.equal(11)
|
|
expect(pattern.parts[0].partC.paths.b.ops[0].to.x).to.equal(2)
|
|
expect(pattern.parts[0].partC.paths.b.ops[0].to.y).to.equal(2)
|
|
expect(pattern.parts[0].partC.paths.b.ops[1].to.x).to.equal(22)
|
|
expect(pattern.parts[0].partC.paths.b.ops[1].to.y).to.equal(22)
|
|
expect(pattern.parts[0].partC.paths.c.ops[0].to.x).to.equal(3)
|
|
expect(pattern.parts[0].partC.paths.c.ops[0].to.y).to.equal(3)
|
|
expect(pattern.parts[0].partC.paths.c.ops[1].to.x).to.equal(33)
|
|
expect(pattern.parts[0].partC.paths.c.ops[1].to.y).to.equal(33)
|
|
// Paths in partR
|
|
expect(pattern.parts[0].partD.paths.d.ops[0].to.x).to.equal(4)
|
|
expect(pattern.parts[0].partD.paths.d.ops[0].to.y).to.equal(4)
|
|
expect(pattern.parts[0].partD.paths.d.ops[1].to.x).to.equal(44)
|
|
expect(pattern.parts[0].partD.paths.d.ops[1].to.y).to.equal(44)
|
|
})
|
|
|
|
it('Pattern.init() should load a single plugin', () => {
|
|
const plugin = {
|
|
name: 'example',
|
|
version: 1,
|
|
hooks: {
|
|
preRender: function (svg) {
|
|
svg.attributes.add('freesewing:plugin-example', 1)
|
|
},
|
|
},
|
|
}
|
|
const part = {
|
|
name: 'test.part',
|
|
plugins: plugin,
|
|
draft: (part) => part,
|
|
}
|
|
const design = new Design({ parts: [part] })
|
|
const pattern = new design()
|
|
pattern.init()
|
|
expect(pattern.hooks.preRender.length).to.equal(1)
|
|
})
|
|
|
|
it('Pattern.init() should load array of plugins', () => {
|
|
const plugin1 = {
|
|
name: 'example1',
|
|
version: 1,
|
|
hooks: {
|
|
preRender: function (svg) {
|
|
svg.attributes.add('freesewing:plugin-example1', 1)
|
|
},
|
|
},
|
|
}
|
|
const plugin2 = {
|
|
name: 'example2',
|
|
version: 2,
|
|
hooks: {
|
|
preRender: function (svg) {
|
|
svg.attributes.add('freesewing:plugin-example2', 2)
|
|
},
|
|
},
|
|
}
|
|
|
|
const design = new Design({ plugins: [plugin1, plugin2] })
|
|
const pattern = new design()
|
|
pattern.init()
|
|
expect(pattern.hooks.preRender.length).to.equal(2)
|
|
})
|
|
it('Pattern.init() should load conditional plugin', () => {
|
|
const plugin = {
|
|
name: 'example',
|
|
version: 1,
|
|
hooks: {
|
|
preRender: function (svg) {
|
|
svg.attributes.add('freesewing:plugin-example', 1)
|
|
},
|
|
},
|
|
}
|
|
const condition = () => true
|
|
const design = new Design({ plugins: [{ plugin, condition }] })
|
|
const pattern = new design()
|
|
pattern.init()
|
|
expect(pattern.hooks.preRender.length).to.equal(1)
|
|
})
|
|
|
|
it('Pattern.init() should not load conditional plugin', () => {
|
|
const plugin = {
|
|
name: 'example',
|
|
version: 1,
|
|
hooks: {
|
|
preRender: function (svg) {
|
|
svg.attributes.add('freesewing:plugin-example', 1)
|
|
},
|
|
},
|
|
}
|
|
const condition = () => false
|
|
const design = new Design({ plugins: { plugin, condition } })
|
|
const pattern = new design()
|
|
expect(pattern.hooks.preRender.length).to.equal(0)
|
|
})
|
|
|
|
it('Pattern.init() should load multiple conditional plugins', () => {
|
|
const plugin = {
|
|
name: 'example',
|
|
version: 1,
|
|
hooks: {
|
|
preRender: function (svg) {
|
|
svg.attributes.add('freesewing:plugin-example', 1)
|
|
},
|
|
},
|
|
}
|
|
const condition1 = () => true
|
|
const condition2 = () => false
|
|
const design = new Design({
|
|
plugins: [
|
|
{ plugin, condition: condition1 },
|
|
{ plugin, condition: condition2 },
|
|
],
|
|
})
|
|
const pattern = new design()
|
|
pattern.init()
|
|
expect(pattern.hooks.preRender.length).to.equal(1)
|
|
})
|
|
|
|
it('Pattern.init() should register a hook via on', () => {
|
|
const Pattern = new Design()
|
|
const pattern = new Pattern()
|
|
let count = 0
|
|
pattern.on('preDraft', function () {
|
|
count++
|
|
})
|
|
pattern.draft()
|
|
expect(count).to.equal(1)
|
|
})
|
|
|
|
it('Pattern.init() should register a hook from a plugin', () => {
|
|
const Pattern = new Design()
|
|
const pattern = new Pattern()
|
|
let count = 0
|
|
pattern._draft = () => {}
|
|
const plugin = {
|
|
name: 'test',
|
|
version: '0.1-test',
|
|
hooks: {
|
|
preDraft: function () {
|
|
count++
|
|
},
|
|
},
|
|
}
|
|
pattern.use(plugin)
|
|
pattern.draft()
|
|
expect(count).to.equal(1)
|
|
})
|
|
|
|
it('Pattern.init() should register multiple methods on a single hook', () => {
|
|
const plugin = {
|
|
name: 'test',
|
|
version: '0.1-test',
|
|
hooks: {
|
|
preDraft: [
|
|
function () {
|
|
count++
|
|
},
|
|
function () {
|
|
count++
|
|
},
|
|
],
|
|
},
|
|
}
|
|
const Pattern = new Design()
|
|
const pattern = new Pattern()
|
|
let count = 0
|
|
pattern._draft = () => {}
|
|
pattern.use(plugin)
|
|
pattern.draft()
|
|
expect(count).to.equal(2)
|
|
})
|
|
|
|
it('Should check whether created parts get the pattern context', () => {
|
|
const part = {
|
|
name: 'test',
|
|
draft: ({ part }) => part,
|
|
}
|
|
const Pattern = new Design({ parts: [part] })
|
|
const pattern = new Pattern()
|
|
pattern.draft()
|
|
const context = pattern.parts[0].test.context
|
|
expect(typeof context).to.equal('object')
|
|
expect(typeof context.parts).to.equal('object')
|
|
expect(typeof context.config).to.equal('object')
|
|
expect(typeof context.config.options).to.equal('object')
|
|
expect(typeof pattern.parts[0].test.context.config.data).to.equal('object')
|
|
expect(Array.isArray(context.config.measurements)).to.equal(true)
|
|
expect(Array.isArray(context.config.optionalMeasurements)).to.equal(true)
|
|
expect(Array.isArray(context.config.parts)).to.equal(true)
|
|
expect(Array.isArray(context.config.plugins)).to.equal(true)
|
|
expect(context.settings).to.equal(pattern.settings[0])
|
|
expect(typeof context.store).to.equal('object')
|
|
expect(typeof context.store.log).to.equal('object')
|
|
expect(typeof context.store.log.debug).to.equal('function')
|
|
expect(typeof context.store.log.info).to.equal('function')
|
|
expect(typeof context.store.log.warning).to.equal('function')
|
|
expect(typeof context.store.log.error).to.equal('function')
|
|
expect(typeof context.store.logs).to.equal('object')
|
|
expect(Array.isArray(context.store.logs.debug)).to.equal(true)
|
|
expect(Array.isArray(context.store.logs.info)).to.equal(true)
|
|
expect(Array.isArray(context.store.logs.warning)).to.equal(true)
|
|
expect(Array.isArray(context.store.logs.error)).to.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('Pattern.settings', () => {
|
|
const part = {
|
|
name: 'test.part',
|
|
options: {
|
|
pct: { pct: 30, min: 10, max: 50 },
|
|
altpct: { pct: 30, min: 10, max: 50 },
|
|
mm: { mm: 12, min: 4, max: 23 },
|
|
deg: { deg: 2, min: 1, max: 3 },
|
|
list: {
|
|
dflt: 'd',
|
|
choices: ['a', 'b', 'c', 'd'],
|
|
},
|
|
count: { count: 4, min: 1, max: 13 },
|
|
bool: { bool: false },
|
|
},
|
|
draft: () => {},
|
|
}
|
|
const Pattern = new Design({
|
|
data: {
|
|
name: 'test',
|
|
version: '1.2.3',
|
|
},
|
|
parts: [part],
|
|
})
|
|
const pattern = new Pattern()
|
|
pattern.init()
|
|
|
|
it('Pattern settings should contain percentage options', () => {
|
|
expect(pattern.settings[0].options.pct).to.equal(0.3)
|
|
})
|
|
|
|
it('Pattern settings should contain millimeter options', () => {
|
|
expect(pattern.settings[0].options.mm).to.equal(12)
|
|
})
|
|
|
|
it('Pattern settings should contain degree options', () => {
|
|
expect(pattern.settings[0].options.deg).to.equal(2)
|
|
})
|
|
|
|
it('Pattern settings should contain list options', () => {
|
|
expect(pattern.settings[0].options.list).to.equal('d')
|
|
})
|
|
|
|
it('Pattern settings should contain count options', () => {
|
|
expect(pattern.settings[0].options.count).to.equal(4)
|
|
})
|
|
|
|
it('Pattern settings should contain bool options', () => {
|
|
expect(pattern.settings[0].options.bool).to.equal(false)
|
|
})
|
|
|
|
it('Pattern should throw an error for an unknown option', () => {
|
|
const part = {
|
|
name: 'test.part',
|
|
options: { unknown: { foo: 30 } },
|
|
draft: () => {},
|
|
}
|
|
const Pattern = new Design({
|
|
data: { name: 'test', version: '1.2.3' },
|
|
parts: [part],
|
|
})
|
|
const pattern = new Pattern()
|
|
expect(() => pattern.init()).to.throw()
|
|
})
|
|
})
|
|
})
|