freesewing/packages/plugin-bartack/tests/bartack.test.js

import freesewing from '@freesewing/core'
import { version } from '../package.json'
let chai = require('chai')
let expect = chai.expect
chai.use(require('chai-string'))
let plugin = require('../dist/index.js')
let round = freesewing.utils.round

describe('Bartack plugin', function () {
  it('Should set the plugin name:version attribute', () => {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin).render()
    expect(pattern.svg.attributes.get('freesewing:plugin-bartack')).to.equal(version)
  })

  it('draws a default bartack from a point', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    pattern.parts.test.points.from = new pattern.Point(10, 20)
    let { macro } = pattern.parts.test.shorthand()
    macro('bartack', {
      anchor: pattern.parts.test.points.from,
    })
    let c = pattern.parts.test.paths.bartack
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
    expect(c.ops[0].type).to.equal('move')
    expect(c.ops[0].to.x).to.equal(10)
    expect(c.ops[0].to.y).to.equal(21.5)
    expect(c.ops[1].type).to.equal('line')
    expect(c.ops[1].to.x).to.equal(10)
    expect(c.ops[1].to.y).to.equal(21.5)
    expect(c.ops[2].to.x).to.equal(10)
    expect(c.ops[2].to.y).to.equal(18.5)
    expect(c.ops[3].to.x).to.equal(11)
    expect(c.ops[3].to.y).to.equal(21.5)
    expect(c.ops[4].to.x).to.equal(11)
    expect(c.ops[4].to.y).to.equal(18.5)
    expect(c.ops).to.have.lengthOf(31)
  })

  it('draws a bartack along a path', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    let from = new pattern.Point(10, 20)
    let to = new pattern.Point(10, 30)

    let { macro } = pattern.parts.test.shorthand()
    macro('bartack', {
      path: new pattern.Path().move(from).line(to),
    })
    let c = pattern.parts.test.paths.bartack
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
    expect(c.ops[0].type).to.equal('move')
    expect(c.ops[0].to.x).to.equal(8.5)
    expect(c.ops[0].to.y).to.equal(20)
    expect(c.ops[1].type).to.equal('line')
    expect(c.ops[1].to.x).to.equal(8.5)
    expect(c.ops[1].to.y).to.equal(20)
    expect(c.ops[2].to.x).to.equal(11.5)
    expect(c.ops[2].to.y).to.equal(20)
    expect(c.ops[3].to.x).to.equal(8.5)
    expect(c.ops[3].to.y).to.equal(21)
    expect(c.ops[4].to.x).to.equal(11.5)
    expect(c.ops[4].to.y).to.equal(21)
    expect(c.ops).to.have.lengthOf(21)
  })

  it('can be called using the bartackAlong syntax', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    let from = new pattern.Point(10, 20)
    let to = new pattern.Point(10, 100)

    let { macro } = pattern.parts.test.shorthand()
    macro('bartackAlong', {
      path: new pattern.Path().move(from).line(to),
      start: 10,
      end: 30,
    })
    let c = pattern.parts.test.paths.bartack
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
    expect(c.ops[0].type).to.equal('move')
    expect(round(c.ops[0].to.x)).to.equal(8.5)
    expect(c.ops[0].to.y).to.equal(30)
    expect(c.ops[1].type).to.equal('line')
    expect(round(c.ops[1].to.x)).to.equal(8.5)
    expect(c.ops[1].to.y).to.equal(30)
    expect(round(c.ops[2].to.x)).to.equal(11.5)
    expect(c.ops[2].to.y).to.equal(30)
    expect(round(c.ops[3].to.x)).to.equal(8.5)
    expect(c.ops[3].to.y).to.equal(31)
    expect(round(c.ops[4].to.x)).to.equal(11.5)
    expect(c.ops[4].to.y).to.equal(31)
    expect(c.ops).to.have.lengthOf(41)
  })

  it('can be called using the bartackFractionAlong syntax', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    let from = new pattern.Point(10, 20)
    let to = new pattern.Point(10, 100)

    let { macro } = pattern.parts.test.shorthand()
    macro('bartackFractionAlong', {
      path: new pattern.Path().move(from).line(to),
      start: 0.2,
      end: 0.8,
    })
    let c = pattern.parts.test.paths.bartack
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
    expect(c.ops[0].type).to.equal('move')
    expect(round(c.ops[0].to.x)).to.equal(8.5)
    expect(c.ops[0].to.y).to.equal(36)
    expect(c.ops[1].type).to.equal('line')
    expect(round(c.ops[1].to.x)).to.equal(8.5)
    expect(c.ops[1].to.y).to.equal(36)
    expect(round(c.ops[2].to.x)).to.equal(11.5)
    expect(c.ops[2].to.y).to.equal(36)
    expect(round(c.ops[3].to.x)).to.equal(8.5)
    expect(c.ops[3].to.y).to.equal(37)
    expect(round(c.ops[4].to.x)).to.equal(11.5)
    expect(c.ops[4].to.y).to.equal(37)
    expect(c.ops).to.have.lengthOf(97)
  })

  it('has configurable length', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    pattern.parts.test.points.from = new pattern.Point(10, 20)
    let { macro } = pattern.parts.test.shorthand()
    macro('bartack', {
      anchor: pattern.parts.test.points.from,
      length: 20,
    })
    let c = pattern.parts.test.paths.bartack
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
    expect(c.ops[0].type).to.equal('move')
    expect(c.ops[0].to.x).to.equal(10)
    expect(c.ops[0].to.y).to.equal(21.5)
    expect(c.ops[1].type).to.equal('line')
    expect(c.ops[1].to.x).to.equal(10)
    expect(c.ops[1].to.y).to.equal(21.5)
    expect(c.ops[2].to.x).to.equal(10)
    expect(c.ops[2].to.y).to.equal(18.5)
    expect(c.ops[3].to.x).to.equal(11)
    expect(c.ops[3].to.y).to.equal(21.5)
    expect(c.ops[4].to.x).to.equal(11)
    expect(c.ops[4].to.y).to.equal(18.5)
    expect(c.ops).to.have.lengthOf(41)
  })

  it('has configurable width', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    pattern.parts.test.points.from = new pattern.Point(10, 20)
    let { macro } = pattern.parts.test.shorthand()
    macro('bartack', {
      anchor: pattern.parts.test.points.from,
      width: 5,
    })
    let c = pattern.parts.test.paths.bartack
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
    expect(c.ops[0].type).to.equal('move')
    expect(c.ops[0].to.x).to.equal(10)
    expect(c.ops[0].to.y).to.equal(22.5)
    expect(c.ops[1].type).to.equal('line')
    expect(c.ops[1].to.x).to.equal(10)
    expect(c.ops[1].to.y).to.equal(22.5)
    expect(c.ops[2].to.x).to.equal(10)
    expect(c.ops[2].to.y).to.equal(17.5)
    expect(round(c.ops[3].to.x)).to.equal(11.67)
    expect(c.ops[3].to.y).to.equal(22.5)
    expect(round(c.ops[4].to.x)).to.equal(11.67)
    expect(c.ops[4].to.y).to.equal(17.5)
    expect(c.ops).to.have.lengthOf(19)
  })

  it('has configurable angle', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    pattern.parts.test.points.from = new pattern.Point(10, 20)
    let { macro } = pattern.parts.test.shorthand()
    macro('bartack', {
      anchor: pattern.parts.test.points.from,
      angle: 45,
    })
    let c = pattern.parts.test.paths.bartack
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
    expect(c.ops[0].type).to.equal('move')
    expect(round(c.ops[0].to.x)).to.equal(11.06)
    expect(round(c.ops[0].to.y)).to.equal(21.06)
    expect(c.ops[1].type).to.equal('line')
    expect(round(c.ops[1].to.x)).to.equal(11.06)
    expect(round(c.ops[1].to.y)).to.equal(21.06)
    expect(round(c.ops[2].to.x)).to.equal(8.94)
    expect(round(c.ops[2].to.y)).to.equal(18.94)
    expect(round(c.ops[3].to.x)).to.equal(11.72)
    expect(round(c.ops[3].to.y)).to.equal(20.4)
    expect(round(c.ops[4].to.x)).to.equal(9.6)
    expect(round(c.ops[4].to.y)).to.equal(18.28)
    expect(c.ops).to.have.lengthOf(33)
  })

  it('has configurable suffix', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    pattern.parts.test.points.from = new pattern.Point(10, 20)
    let { macro } = pattern.parts.test.shorthand()
    macro('bartack', {
      anchor: pattern.parts.test.points.from,
      suffix: 'foo',
    })
    let c = pattern.parts.test.paths.bartackfoo
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
  })

  it('has configurable prefix', function () {
    let pattern = new freesewing.Pattern()
    pattern.use(plugin)
    pattern.parts.test = new pattern.Part()
    pattern.parts.test.points.from = new pattern.Point(10, 20)
    let { macro } = pattern.parts.test.shorthand()
    macro('bartack', {
      anchor: pattern.parts.test.points.from,
      prefix: 'foo',
    })
    let c = pattern.parts.test.paths.foobartack
    expect(c.attributes.get('class')).to.equal('stroke-sm bartack')
  })
})