26e282f5b7
Note that the tests for Lumina are failing, but that's not related to the chai upgrade, rather it seems these tests fail because of issues in the design that we'll tackle later (it's a brand new design yet to be released).
518 lines
17 KiB
JavaScript
518 lines
17 KiB
JavaScript
import { expect } from 'chai'
|
|
import { round, Point } from '../src/index.mjs'
|
|
|
|
describe('Point', () => {
|
|
it('Should return point object', () => {
|
|
let result = new Point(2, 4)
|
|
expect(result).to.be.a('object')
|
|
expect(result.x).to.equal(2)
|
|
expect(result.y).to.equal(4)
|
|
})
|
|
|
|
it('Should not limit point precision', () => {
|
|
let result = new Point(2.12345, 4.98765)
|
|
expect(result.x).to.equal(2.12345)
|
|
expect(result.y).to.equal(4.98765)
|
|
})
|
|
|
|
it('Should return distance', () => {
|
|
expect(round(new Point(2, 4).dist(new Point(-123, -32423)))).to.equal(32427.24)
|
|
})
|
|
|
|
it('Should return slope', () => {
|
|
let from = new Point(0, 0)
|
|
expect(from.slope(new Point(0, -10))).to.equal(-Infinity)
|
|
expect(from.slope(new Point(10, 0))).to.equal(0)
|
|
expect(from.slope(new Point(0, 10))).to.equal(Infinity)
|
|
expect(from.slope(new Point(-10, 0))).to.equal(-0)
|
|
expect(from.slope(new Point(10, 10))).to.equal(1)
|
|
expect(from.slope(new Point(-10, 5))).to.equal(-0.5)
|
|
})
|
|
|
|
it('Should return angle', () => {
|
|
let from = new Point(0, 0)
|
|
expect(from.angle(new Point(10, 0))).to.equal(0)
|
|
expect(from.angle(new Point(-20, 0))).to.equal(180)
|
|
expect(from.angle(new Point(0, -10))).to.equal(90)
|
|
expect(from.angle(new Point(0, 10))).to.equal(270)
|
|
expect(from.angle(new Point(10, -10))).to.equal(45)
|
|
expect(from.angle(new Point(10, 10))).to.equal(315)
|
|
})
|
|
|
|
it('Should copy a point', () => {
|
|
let result = new Point(2, 4).copy()
|
|
expect(result.x).to.equal(2)
|
|
expect(result.y).to.equal(4)
|
|
})
|
|
|
|
it('Should check points for equality', () => {
|
|
let a = new Point(-123, 456)
|
|
let b = new Point(-123, 456)
|
|
expect(a).to.deep.equal(b)
|
|
})
|
|
|
|
it('Should flip point around unset X value', () => {
|
|
let result = new Point(2, 4).flipX()
|
|
expect(result.x).to.equal(-2)
|
|
expect(result.y).to.equal(4)
|
|
})
|
|
|
|
it('Should flip point around X value that is zero', () => {
|
|
let flip = new Point(0, 0)
|
|
let result = new Point(2, 4).flipX(flip)
|
|
expect(result.x).to.equal(-2)
|
|
expect(result.y).to.equal(4)
|
|
})
|
|
|
|
it('Should flip point around X value', () => {
|
|
let result = new Point(2, 4).flipX(new Point(-20, 19))
|
|
expect(result.x).to.equal(-42)
|
|
expect(result.y).to.equal(4)
|
|
})
|
|
|
|
it('Should flip point around unset Y value', () => {
|
|
let result = new Point(2, 4).flipY()
|
|
expect(result.x).to.equal(2)
|
|
expect(result.y).to.equal(-4)
|
|
})
|
|
|
|
it('Should flip point around Y value that is zero', () => {
|
|
let flip = new Point(0, 0)
|
|
let result = new Point(2, 4).flipY(flip)
|
|
expect(result.x).to.equal(2)
|
|
expect(result.y).to.equal(-4)
|
|
})
|
|
|
|
it('Should flip point around Y value', () => {
|
|
let result = new Point(2, 4).flipY(new Point(12, -14))
|
|
expect(result.x).to.equal(2)
|
|
expect(result.y).to.equal(-32)
|
|
})
|
|
|
|
it('Should shift a point', () => {
|
|
let origin = new Point(0, 0)
|
|
let n = origin.shift(90, 10)
|
|
let e = origin.shift(0, 10)
|
|
let s = origin.shift(270, 10)
|
|
let w = origin.shift(180, 10)
|
|
expect(round(n.x)).to.equal(0)
|
|
expect(round(n.y)).to.equal(-10)
|
|
expect(round(e.x)).to.equal(10)
|
|
expect(round(e.y)).to.equal(0)
|
|
expect(round(s.x)).to.equal(0)
|
|
expect(round(s.y)).to.equal(10)
|
|
expect(round(w.x)).to.equal(-10)
|
|
expect(round(w.y)).to.equal(0)
|
|
let rand = origin.shift(-123, 456)
|
|
expect(round(rand.x)).to.equal(-248.36)
|
|
expect(round(rand.y)).to.equal(382.43)
|
|
})
|
|
|
|
it('Should shift a point towards another', () => {
|
|
let origin = new Point(0, 0)
|
|
let n = new Point(0, -10)
|
|
let e = new Point(10, 0)
|
|
let s = new Point(0, 10)
|
|
let w = new Point(-10, 0)
|
|
let sn = origin.shiftTowards(n, 123)
|
|
let se = origin.shiftTowards(e, 123)
|
|
let ss = origin.shiftTowards(s, 123)
|
|
let sw = origin.shiftTowards(w, 123)
|
|
expect(round(sn.x)).to.equal(0)
|
|
expect(round(sn.y)).to.equal(-123)
|
|
expect(round(se.x)).to.equal(123)
|
|
expect(round(se.y)).to.equal(0)
|
|
expect(round(ss.x)).to.equal(0)
|
|
expect(round(ss.y)).to.equal(123)
|
|
expect(round(sw.x)).to.equal(-123)
|
|
expect(round(sw.y)).to.equal(0)
|
|
expect(round(sw.shiftTowards(sn, 100).x)).to.equal(-52.29)
|
|
expect(round(ss.shiftTowards(se, 200).y)).to.equal(-18.42)
|
|
})
|
|
|
|
describe('shiftFractionTowards', () => {
|
|
it('Should shift a point a fraction towards another', () => {
|
|
let origin = new Point(0, 0)
|
|
let s = new Point(0, 10)
|
|
let ss = origin.shiftFractionTowards(s, 0.5)
|
|
expect(round(ss.x)).to.equal(0)
|
|
expect(round(ss.y)).to.equal(5)
|
|
})
|
|
|
|
it('Should shift a point a fraction beyond another if the fraction is > 1', () => {
|
|
let origin = new Point(0, 0)
|
|
let n = new Point(0, -10)
|
|
let sn = origin.shiftFractionTowards(n, 1.5)
|
|
expect(round(sn.x)).to.equal(0)
|
|
expect(round(sn.y)).to.equal(-15)
|
|
})
|
|
|
|
it('Should shift a point a fraction away from another if the fraction is < 0', () => {
|
|
let origin = new Point(0, 0)
|
|
let n = new Point(0, -10)
|
|
let sn = origin.shiftFractionTowards(n, -0.5)
|
|
expect(round(sn.x)).to.equal(0)
|
|
expect(round(sn.y)).to.equal(5)
|
|
})
|
|
})
|
|
|
|
it('Should shift a point beyond another', () => {
|
|
let origin = new Point(0, 0)
|
|
let n = new Point(0, -10)
|
|
let e = new Point(10, 0)
|
|
let s = new Point(0, 10)
|
|
let w = new Point(-10, 0)
|
|
let sn = origin.shiftOutwards(n, 100)
|
|
let se = origin.shiftOutwards(e, 100)
|
|
let ss = origin.shiftOutwards(s, 100)
|
|
let sw = origin.shiftOutwards(w, 100)
|
|
expect(round(sn.x)).to.equal(0)
|
|
expect(round(sn.y)).to.equal(-110)
|
|
expect(round(se.x)).to.equal(110)
|
|
expect(round(se.y)).to.equal(0)
|
|
expect(round(ss.x)).to.equal(0)
|
|
expect(round(ss.y)).to.equal(110)
|
|
expect(round(sw.x)).to.equal(-110)
|
|
expect(round(sw.y)).to.equal(0)
|
|
expect(round(sw.shiftOutwards(sn, 100).x)).to.equal(70.71)
|
|
expect(round(ss.shiftOutwards(se, 200).y)).to.equal(-141.42)
|
|
})
|
|
|
|
it('Should rotate a point around another', () => {
|
|
let sun = new Point(0, 0)
|
|
let moon = new Point(10, 0)
|
|
let a = moon.rotate(90, sun)
|
|
expect(round(a.x)).to.equal(0)
|
|
expect(round(a.y)).to.equal(-10)
|
|
let b = moon.rotate(-90, sun)
|
|
expect(round(b.x)).to.equal(0)
|
|
expect(round(b.y)).to.equal(10)
|
|
let c = moon.rotate(180, sun)
|
|
expect(round(c.x)).to.equal(-10)
|
|
expect(round(c.y)).to.equal(0)
|
|
let sun2 = new Point(222, 44)
|
|
let moon2 = new Point(212, 41)
|
|
let d = moon2.rotate(90, sun2)
|
|
expect(round(d.x)).to.equal(219)
|
|
expect(round(d.y)).to.equal(54)
|
|
})
|
|
|
|
it('Should set an attribute', () => {
|
|
let p = new Point(0, 0).attr('class', 'test')
|
|
expect(p.attributes.get('class')).to.equal('test')
|
|
p.attr('class', 'more')
|
|
expect(p.attributes.get('class')).to.equal('test more')
|
|
p.attr('class', 'less', true)
|
|
expect(p.attributes.get('class')).to.equal('less')
|
|
})
|
|
|
|
it('Should detect points in the same location', () => {
|
|
let p1 = new Point(123, 456)
|
|
let p2 = new Point(123, 456)
|
|
expect(p1.sitsOn(p2)).to.equal(true)
|
|
p2.x = 122.99
|
|
expect(p1.sitsOn(p2)).to.equal(false)
|
|
})
|
|
|
|
it('Should clone a point', () => {
|
|
let p1 = new Point(123, 456).attr('class', 'something')
|
|
p1.attr('class', 'else')
|
|
let p2 = p1.clone()
|
|
expect(p2.sitsOn(p1)).to.equal(true)
|
|
expect(p2.attributes.get('class')).to.equal('something else')
|
|
})
|
|
|
|
it('Should translate a point', () => {
|
|
let p1 = new Point(10, 20)
|
|
let p2 = p1.translate(15, 50)
|
|
expect(p2.x).to.equal(25)
|
|
expect(p2.y).to.equal(70)
|
|
})
|
|
|
|
it('Should add log methods to a point', () => {
|
|
const log = () => 'hello'
|
|
const p1 = new Point(10, 20).__withLog(log)
|
|
expect(p1.log()).to.equal('hello')
|
|
})
|
|
|
|
it('Should log a warning on invalid point coordinates', () => {
|
|
const invalid = { x: false, y: false }
|
|
const logX = { warn: () => (invalid.x = true) }
|
|
const logY = { warn: () => (invalid.y = true) }
|
|
const p1 = new Point('a', 10).__withLog(logX)
|
|
const p2 = new Point(20, 'b').__withLog(logY)
|
|
expect(invalid.x).to.equal(false)
|
|
expect(invalid.y).to.equal(false)
|
|
p1.__check()
|
|
p2.__check()
|
|
expect(invalid.x).to.equal(true)
|
|
expect(invalid.y).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning if rotation is not a number', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
const p2 = new Point(20, 20).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
p1.rotate('a', p2)
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning if rotating around what is not a point', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.rotate(45, 'a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it("Should log a warning when flipX'ing around what is not a point", () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.flipX('a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it("Should log a warning when flipY'ing around what is not a point", () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.flipY('a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when shifting with a distance that is not a number', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.shift(0, 'a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when shifting with an angle that is not a number', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.shift('a', 12)
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when shifting towards with a distance that is not a number', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
const p2 = new Point(20, 20).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.shiftTowards(p2, 'a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when shifting towards with a target that is not a point', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.shiftTowards('a', 10)
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when shifting fraction towards with a distance that is not a number', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
const p2 = new Point(20, 20).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.shiftFractionTowards(p2, 'a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when shifting a fraction towards with a target that is not a point', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.shiftFractionTowards('a', 0.1)
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when shifting outowards with a distance that is not a number', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
const p2 = new Point(20, 20).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.shiftOutwards(p2, 'a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when shifting a outowards with a target that is not a point', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.shiftOutwards('a', 0.1)
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when translating with an X-delta that is not a number', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.translate('a', 10)
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when translating with an Y-delta that is not a number', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.translate(10, 'a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when sitsOn receives a non-point', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.sitsOn('a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should log a warning when sitsRoughlyOn receives a non-point', () => {
|
|
let invalid = false
|
|
const log = { warn: () => (invalid = true) }
|
|
const p1 = new Point(10, 10).__withLog(log)
|
|
expect(invalid).to.equal(false)
|
|
try {
|
|
p1.sitsRoughlyOn('a')
|
|
} catch (err) {
|
|
expect('' + err).to.contain('check is not a function')
|
|
}
|
|
expect(invalid).to.equal(true)
|
|
})
|
|
|
|
it('Should add the data-text property in a chainable way', () => {
|
|
const p1 = new Point(10, 10).addText('hello').addText('world')
|
|
expect(p1.attributes.get('data-text')).to.equal('hello world')
|
|
})
|
|
|
|
it('Should set the data-text property in a chainable way', () => {
|
|
const p1 = new Point(10, 10).setText('hello')
|
|
expect(p1.attributes.get('data-text')).to.equal('hello')
|
|
})
|
|
|
|
it('Should set the data-text-class property in a chainable way', () => {
|
|
const p1 = new Point(10, 10).addText('hello', 'fabric').addText('world', 'lining')
|
|
expect(p1.attributes.get('data-text')).to.equal('hello world')
|
|
expect(p1.attributes.get('data-text-class')).to.equal('fabric lining')
|
|
})
|
|
|
|
it('Should set the data-text-class property in a chainable way', () => {
|
|
const p1 = new Point(10, 10).setText('hello', 'fabric')
|
|
expect(p1.attributes.get('data-text')).to.equal('hello')
|
|
expect(p1.attributes.get('data-text-class')).to.equal('fabric')
|
|
})
|
|
|
|
it('Should add the data-circle property in a chainable way', () => {
|
|
const p1 = new Point(10, 10).addCircle('20').addCircle('30').addCircle('40')
|
|
const radius = p1.attributes.getAsArray('data-circle')
|
|
expect(radius.length).to.equal(3)
|
|
expect(radius[0]).to.equal('20')
|
|
expect(radius[1]).to.equal('30')
|
|
expect(radius[2]).to.equal('40')
|
|
})
|
|
|
|
it('Should set the data-circle property in a chainable way', () => {
|
|
const p1 = new Point(10, 10).setCircle('20')
|
|
expect(p1.attributes.get('data-circle')).to.equal('20')
|
|
})
|
|
|
|
it('Should add the data-circle-class property in a chainable way', () => {
|
|
const p1 = new Point(10, 10)
|
|
.addCircle('20', 'fabric')
|
|
.addCircle('30', 'lining')
|
|
.addCircle('40', 'interfacing')
|
|
const radius = p1.attributes.getAsArray('data-circle')
|
|
const classes = p1.attributes.getAsArray('data-circle-class')
|
|
expect(radius.length).to.equal(3)
|
|
expect(radius[0]).to.equal('20')
|
|
expect(radius[1]).to.equal('30')
|
|
expect(radius[2]).to.equal('40')
|
|
expect(classes.length).to.equal(3)
|
|
expect(classes[0]).to.equal('fabric')
|
|
expect(classes[1]).to.equal('lining')
|
|
expect(classes[2]).to.equal('interfacing')
|
|
})
|
|
|
|
it('Should set the data-circle-class property in a chainable way', () => {
|
|
const p1 = new Point(10, 10).setCircle('20', 'fabric')
|
|
expect(p1.attributes.get('data-circle')).to.equal('20')
|
|
expect(p1.attributes.get('data-circle-class')).to.equal('fabric')
|
|
})
|
|
})
|