freesewing/packages/core/tests/pattern-other.test.mjs

import chai from 'chai'
import { Design } from '../src/index.mjs'

const expect = chai.expect

describe('Pattern', () => {

  it('Should log an error when a part does not have a name', () => {
    const part = { draft: ({ part }) => part }
    const design = new Design()
    const pattern = new design()
    pattern.addPart(part)
    expect(pattern.store.logs.error.length).to.equal(1)
    expect(pattern.store.logs.error[0]).to.equal('Part must have a name')
  })

  it('Should log an error when a part does not have a draft method', () => {
    const from = {
      name: 'test',
      noDraft: ({ points, part }) => {
        points.test = false
        return part
      }
    }
    const to = {
      name: 'testTo',
      from,
      draft: ({ points, part }) => {
        return part
      }
    }
    const design = new Design({ parts: [ to ]})
    const pattern = new design()
    pattern.draft()
    expect(pattern.setStores[0].logs.error.length).to.equal(1)
    expect(pattern.setStores[0].logs.error[0]).to.equal('Unable to draft pattern part __test__. Part.draft() is not callable')
  })

  it('Not returning the part from the draft method should log an error', () => {
    const test = {
      name: 'test',
      draft: ({ points, part }) => {}
    }
    const design = new Design({ parts: [ test ]})
    const pattern = new design()
    pattern.draft()
    expect(pattern.setStores[0].logs.error.length).to.equal(1)
    expect(pattern.setStores[0].logs.error[0]).to.equal('Result of drafting part test was undefined. Did you forget to return the part?')
  })

  it('Should skip unneeded parts', () => {
    const test = {
      name: 'test',
      draft: ({ points, part }) => part
    }
    const design = new Design({ parts: [ test ]})
    const pattern = new design({ only: ['you'] })
    pattern.draft()
    expect(pattern.setStores[0].logs.debug.length).to.equal(4)
    expect(pattern.setStores[0].logs.debug[3]).to.equal('Part `test` is not needed. Skipping draft and setting hidden to `true`')
  })

  it('Should return the initialized config', () => {
    const test = {
      name: 'test',
      draft: ({ points, part }) => part
    }
    const design = new Design({ parts: [ test ]})
    const pattern = new design({ only: ['you'] })
    const config = pattern.getConfig()
    expect(config.draftOrder.length).to.equal(1)
    expect(config.draftOrder[0]).to.equal('test')
  })

  it('Should skip a plugin that is loaded twice', () => {
    const test = {
      name: 'test',
      draft: ({ points, part }) => part
    }
    const plugin = { name: 'test' }
    const design = new Design({ parts: [ test ]})
    const pattern = new design({ only: ['you'] })
    pattern.use(plugin)
    pattern.use(plugin)
    pattern.use({ plugin })
    pattern.use({ plugin })
    expect(Object.keys(pattern.plugins).length).to.equal(1)
    expect(Object.keys(pattern.plugins)[0]).to.equal('test')
  })

  it('Should log an error of added parts do not have a draft method', () => {
    const design = new Design()
    const pattern = new design()
    pattern.addPart({})
    expect(pattern.store.logs.error.length).to.equal(1)
    expect(pattern.store.logs.error[0]).to.equal('Part must have a draft() method')
  })

  it('Parts in only are never hidden', () => {
    const test = {
      name: 'test',
      hidden: true,
      draft: ({ points, part }) => part
    }
    const design = new Design()
    const pattern = new design({ only: ['test']})
    pattern.__init()
    expect(pattern.__isPartHidden('test')).to.equal(false)
  })

  it('Stacks with parts in only are never hidden', () => {
    const part = {
      name: 'test',
      draft: ({ points, Point, paths, Path, part }) => {
        points.test = new Point(3, 3)

        return part
      },
    }
    const design = new Design({ parts: [part] })
    const pattern = new design({ only: [ 'test' ] })
    pattern.draft().render()
    expect(pattern.__isStackHidden('test')).to.equal(false)
  })

  it('Stacks with parts in only are never hidden', () => {
    const part = {
      name: 'test',
      draft: ({ points, Point, paths, Path, part }) => {
        points.test = new Point(3, 3)

        return part
      },
    }
    const design = new Design({ parts: [part] })
    const pattern = new design({ only: [ 'test' ] })
    pattern.draft().render()
    expect(pattern.__isStackHidden('test')).to.equal(false)
  })

  it('Drafts with errors should not get packed', () => {
    const part= {
      name: 'test',
      draft: ({ points, Point, paths, Path, part }) => {
        points.test = new Point(3, 3)
        joints.foo = 'bar'

        return part
      },
    }
    const design = new Design({ parts: [part] })
    const pattern = new design()
    pattern.draft().render()
    expect(pattern.setStores[0].logs.error.length).to.equal(1)
    expect(pattern.setStores[0].logs.error[0][0]).to.equal('Unable to draft part `test` (set 0)')
  })

  it('Handle layout object', () => {
    const part = {
      name: 'test',
      draft: ({ points, Point, paths, Path, part }) => {
        points.test = new Point(3, 3)

        return part
      },
    }
    const design = new Design({ parts: [part] })
    const pattern = new design({ layout: { stacks: { test: { flipX: true } } } })
    const props = pattern.draft().getRenderProps()
    // FIXME: Add assertions here
    //expect(pattern.__isStackHidden('test')).to.equal(false)
  })
})