refactor(tests): rename e2e to tests

Signed-off-by: braks <78412429+bcakmakoglu@users.noreply.github.com>

tests/cypress/component/1-store/elements/addSelectedElements.cy.ts

@@ -0,0 +1,25 @@
+import { useVueFlow } from '@vue-flow/core'
+import { getElements } from '../../../utils'
+
+const { nodes, edges } = getElements()
+
+describe('Store Action: `addSelectedElements`', () => {
+  const store = useVueFlow({ id: 'test' })
+  let randomNumber: number
+
+  beforeEach(() => {
+    cy.vueFlow({
+      nodes,
+      edges,
+    })
+  })
+
+  beforeEach(() => {
+    randomNumber = Math.floor(Math.random() * [...nodes, ...edges].length)
+    store.addSelectedElements(Array.from({ length: randomNumber }, (_, i) => store.getElements.value[i]))
+  })
+
+  it('adds selected elements to store', () => {
+    expect(store.getSelectedElements.value).to.have.length(randomNumber)
+  })
+})

tests/cypress/component/1-store/elements/removeSelectedElements.cy.ts

@@ -0,0 +1,49 @@
+import type { Elements } from '@vue-flow/core'
+import { isNode, useVueFlow } from '@vue-flow/core'
+import { getElements } from '../../../utils'
+
+const { nodes, edges } = getElements()
+
+describe('Store Action: `removeSelectedElements`', () => {
+  const store = useVueFlow({ id: 'test' })
+  let randomNumber: number
+  let randomNumber2: number
+
+  beforeEach(() => {
+    cy.vueFlow({
+      nodes,
+      edges,
+    })
+  })
+
+  it('removes passed elements from selected elements in store', async () => {
+    randomNumber = Math.floor(Math.random() * [...nodes, ...edges].length)
+    randomNumber2 = Math.floor(Math.random() * randomNumber)
+    store.addSelectedElements(Array.from({ length: randomNumber }, (_, i) => store.getElements.value[i]))
+    store.removeSelectedElements(
+      Array.from({ length: randomNumber2 }, (_, i) => store.getElements.value[i]).reduce((acc, curr) => {
+        if (isNode(curr)) {
+          acc.push(curr)
+        } else {
+          acc.push(curr)
+        }
+
+        return acc
+      }, [] as Elements),
+    )
+
+    await cy.tryAssertion(() => {
+      expect(store.getSelectedElements.value).to.have.length(randomNumber - randomNumber2)
+    })
+  })
+
+  it('resets all selected elements in store when no argument is passed', () => {
+    randomNumber = Math.floor(Math.random() * [...nodes, ...edges].length)
+    store.addSelectedElements(Array.from({ length: randomNumber }, (_, i) => store.getElements.value[i]))
+    store.removeSelectedElements()
+
+    cy.tryAssertion(() => {
+      expect(store.getSelectedElements.value).to.have.length(0)
+    })
+  })
+})

tests/cypress/component/1-store/elements/setElements.cy.ts

@@ -0,0 +1,102 @@
+import { defaultEdgeTypes, defaultNodeTypes, isEdge, isNode, useVueFlow } from '@vue-flow/core'
+import { getElements } from '../../../utils'
+
+const { nodes, edges } = getElements()
+
+describe('Store Action: `setElements`', () => {
+  const store = useVueFlow()
+
+  it('sets elements', () => {
+    store.setElements([...nodes, ...edges])
+
+    expect(store.nodes.value).to.have.length(nodes.length)
+    expect(store.edges.value).to.have.length(edges.length)
+  })
+
+  it('parses elements to flow-elements', () => {
+    store.getEdges.value.forEach((edge) => expect(isEdge(edge)).to.be.true)
+    store.getNodes.value.forEach((node) => expect(isNode(node)).to.be.true)
+  })
+
+  it('has correct element ids', () => {
+    const nodeIds = nodes.map((node) => node.id)
+    const edgeIds = edges.map((edge) => edge.id)
+
+    store.nodes.value.forEach((el) => expect(nodeIds).to.include(el.id))
+    store.edges.value.forEach((el) => expect(edgeIds).to.include(el.id))
+  })
+
+  it('has correct element types', () => {
+    const nodeTypes = nodes.reduce((types, node) => {
+      if (node.type && !types.includes(node.type)) types.push(node.type)
+      return types
+    }, Object.keys(defaultNodeTypes))
+
+    store.nodes.value.forEach((el) => expect(nodeTypes).to.include(el.type))
+
+    const edgeTypes = edges.reduce((types, edge) => {
+      if (edge.type && !types.includes(edge.type)) types.push(edge.type)
+      return types
+    }, Object.keys(defaultEdgeTypes))
+
+    store.edges.value.forEach((el) => expect(edgeTypes).to.include(el.type))
+  })
+
+  describe('test node properties', () => {
+    it('has correct label', () => {
+      store.getNodes.value.forEach((el) => {
+        const node = nodes.find((node) => node.id === el.id)
+        expect(el.label).to.eq(node?.label)
+      })
+    })
+
+    it('has correct position', () => {
+      store.getNodes.value.forEach((el) => {
+        const node = nodes.find((node) => node.id === el.id)
+        expect(JSON.stringify(el.position)).to.eq(JSON.stringify(node?.position || {}))
+      })
+    })
+
+    it('has correct random data', () => {
+      store.getNodes.value.forEach((el) => {
+        const node = nodes.find((node) => node.id === el.id)
+        expect(el.data.randomData).to.eq(node?.data.randomData)
+      })
+    })
+  })
+
+  describe('test edge properties', () => {
+    it('has correct target and source', () => {
+      store.getEdges.value.forEach((el) => {
+        const edge = edges.find((edge) => edge.id === el.id)
+
+        expect(el.source).to.eq(edge?.source)
+        expect(el.target).to.eq(edge?.target)
+      })
+    })
+
+    it('has correct target-node and source-node', () => {
+      store.getEdges.value.forEach((el) => {
+        const edge = edges.find((edge) => edge.id === el.id)
+
+        expect(el.sourceNode.id).to.eq(edge?.source)
+        expect(el.targetNode.id).to.eq(edge?.target)
+      })
+    })
+
+    it('has correct random data', () => {
+      store.getEdges.value.forEach((el) => {
+        const edge = edges.find((edge) => edge.id === el.id)
+        expect(el.data.randomData).to.eq(edge?.data.randomData)
+      })
+    })
+
+    it('is animated', () => {
+      store.getEdges.value.forEach((el) => {
+        const edge = edges.find((edge) => edge.id === el.id)
+
+        expect(el.animated).to.eq(edge?.animated)
+      })
+    })
+  })
+})