oil-formula-calculator/frontend/cypress/e2e/pr27-features.cy.js

describe('PR27 Feature Tests', () => {
  const ADMIN_TOKEN = 'c86ae7afbe10fabe3c1d5e1a7fee74feaadfd5dc7be2ab62'
  const authHeaders = { Authorization: `Bearer ${ADMIN_TOKEN}` }
  const TEST_USERNAME = 'cypress_pr27_user'

  // -------------------------------------------------------------------------
  // API: en_name auto title case on recipe create
  // -------------------------------------------------------------------------
  describe('API: en_name auto title case', () => {
    let recipeId

    after(() => {
      // Cleanup
      if (recipeId) {
        cy.request({
          method: 'DELETE',
          url: `/api/recipes/${recipeId}`,
          headers: authHeaders,
          failOnStatusCode: false
        })
      }
    })

    it('auto title-cases en_name when provided', () => {
      cy.request({
        method: 'POST',
        url: '/api/recipes',
        headers: authHeaders,
        body: {
          name: 'PR27标题测试',
          en_name: 'pain relief blend',
          ingredients: [{ oil_name: '薰衣草', drops: 3 }],
          tags: []
        }
      }).then(res => {
        expect(res.status).to.be.oneOf([200, 201])
        recipeId = res.body.id
      })
    })

    it('verifies en_name is title-cased', () => {
      cy.request('/api/recipes').then(res => {
        const found = res.body.find(r => r.name === 'PR27标题测试')
        expect(found).to.exist
        expect(found.en_name).to.eq('Pain Relief Blend')
        recipeId = found.id
      })
    })

    it('auto translates en_name from Chinese when not provided', () => {
      cy.request({
        method: 'POST',
        url: '/api/recipes',
        headers: authHeaders,
        body: {
          name: '助眠配方',
          ingredients: [{ oil_name: '薰衣草', drops: 5 }],
          tags: []
        }
      }).then(res => {
        expect(res.status).to.be.oneOf([200, 201])
        const autoId = res.body.id

        cy.request('/api/recipes').then(listRes => {
          const found = listRes.body.find(r => r.id === autoId)
          expect(found).to.exist
          // auto_translate('助眠配方') should produce English with "Sleep" and "Blend"
          expect(found.en_name).to.be.a('string')
          expect(found.en_name.length).to.be.greaterThan(0)
          expect(found.en_name).to.include('Sleep')

          // Cleanup
          cy.request({
            method: 'DELETE',
            url: `/api/recipes/${autoId}`,
            headers: authHeaders,
            failOnStatusCode: false
          })
        })
      })
    })
  })

  // -------------------------------------------------------------------------
  // API: delete user transfers diary recipes to admin
  // -------------------------------------------------------------------------
  describe('API: delete user transfers diary', () => {
    let testUserId
    let testUserToken

    // Cleanup leftover test user
    before(() => {
      cy.request({
        url: '/api/users',
        headers: authHeaders
      }).then(res => {
        const leftover = res.body.find(u => u.username === TEST_USERNAME)
        if (leftover) {
          cy.request({
            method: 'DELETE',
            url: `/api/users/${leftover.id || leftover._id}`,
            headers: authHeaders,
            failOnStatusCode: false
          })
        }
      })
    })

    it('creates a test user', () => {
      cy.request({
        method: 'POST',
        url: '/api/users',
        headers: authHeaders,
        body: {
          username: TEST_USERNAME,
          display_name: 'PR27 Test User',
          role: 'editor'
        }
      }).then(res => {
        expect(res.status).to.be.oneOf([200, 201])
        testUserId = res.body.id || res.body._id
        testUserToken = res.body.token
        expect(testUserId).to.be.a('number')
      })
    })

    it('adds a diary entry for the test user', () => {
      const userAuth = { Authorization: `Bearer ${testUserToken}` }
      cy.request({
        method: 'POST',
        url: '/api/diary',
        headers: userAuth,
        body: {
          name: 'PR27用户日记',
          ingredients: [{ oil: '乳香', drops: 4 }, { oil: '薰衣草', drops: 2 }],
          note: '转移测试'
        }
      }).then(res => {
        expect(res.status).to.be.oneOf([200, 201])
      })
    })

    it('deletes the user and transfers diary to admin', () => {
      cy.request({
        method: 'DELETE',
        url: `/api/users/${testUserId}`,
        headers: authHeaders
      }).then(res => {
        expect(res.status).to.eq(200)
        expect(res.body.ok).to.eq(true)
      })
    })

    it('verifies diary was transferred to admin', () => {
      cy.request({
        url: '/api/diary',
        headers: authHeaders
      }).then(res => {
        expect(res.body).to.be.an('array')
        // Transferred diary should have user's name appended
        const transferred = res.body.find(d => d.name && d.name.includes('PR27用户日记') && d.name.includes('PR27 Test User'))
        expect(transferred).to.exist
        expect(transferred.note).to.eq('转移测试')

        // Cleanup: delete the transferred diary
        if (transferred) {
          cy.request({
            method: 'DELETE',
            url: `/api/diary/${transferred.id}`,
            headers: authHeaders,
            failOnStatusCode: false
          })
        }
      })
    })
  })

  // -------------------------------------------------------------------------
  // API: rename recipe auto-retranslates en_name
  // -------------------------------------------------------------------------
  describe('API: rename recipe retranslates en_name', () => {
    let recipeId

    after(() => {
      if (recipeId) {
        cy.request({ method: 'DELETE', url: `/api/recipes/${recipeId}`, headers: authHeaders, failOnStatusCode: false })
      }
    })

    it('creates recipe then renames it, en_name auto-updates', () => {
      cy.request({
        method: 'POST', url: '/api/recipes', headers: authHeaders,
        body: { name: '头痛', ingredients: [{ oil_name: '薰衣草', drops: 3 }], tags: [] }
      }).then(res => {
        recipeId = res.body.id
        // Verify initial en_name
        cy.request('/api/recipes').then(list => {
          const r = list.body.find(x => x.id === recipeId)
          expect(r.en_name).to.include('Headache')
        })
        // Rename to 肩颈按摩
        cy.request({
          method: 'PUT', url: `/api/recipes/${recipeId}`, headers: authHeaders,
          body: { name: '肩颈按摩' }
        }).then(() => {
          cy.request('/api/recipes').then(list => {
            const r = list.body.find(x => x.id === recipeId)
            expect(r.en_name).to.include('Neck')
            expect(r.en_name).to.include('Massage')
          })
        })
      })
    })
  })

  // -------------------------------------------------------------------------
  // API: delete user skips duplicate diary by ingredient content
  // -------------------------------------------------------------------------
  describe('API: delete user skips duplicate diary', () => {
    const DUP_USER = 'cypress_pr27_dup'

    it('creates user with duplicate diary, deletes, verifies skip', () => {
      // Create user
      cy.request({
        method: 'POST', url: '/api/users', headers: authHeaders,
        body: { username: DUP_USER, display_name: 'Dup Test', role: 'viewer' }
      }).then(res => {
        const userId = res.body.id
        const userToken = res.body.token
        const userAuth = { Authorization: `Bearer ${userToken}` }

        // Get a public recipe's ingredients to create a duplicate
        cy.request({ url: '/api/recipes', headers: authHeaders }).then(listRes => {
          const pub = listRes.body[0]
          const dupIngs = pub.ingredients.map(i => ({ oil: i.oil_name, drops: i.drops }))

          // Add diary with same ingredients as public recipe (different name)
          cy.request({
            method: 'POST', url: '/api/diary', headers: userAuth,
            body: { name: '我的重复方', ingredients: dupIngs, note: '' }
          }).then(() => {
            // Delete user
            cy.request({ method: 'DELETE', url: `/api/users/${userId}`, headers: authHeaders }).then(delRes => {
              expect(delRes.body.ok).to.eq(true)
              // Verify duplicate was NOT transferred
              cy.request({ url: '/api/diary', headers: authHeaders }).then(diaryRes => {
                const transferred = diaryRes.body.find(d => d.name && d.name.includes('我的重复方'))
                expect(transferred).to.not.exist
              })
            })
          })
        })
      })
    })
  })

  // -------------------------------------------------------------------------
  // UI: 管理配方 login prompt when not logged in
  // -------------------------------------------------------------------------
  describe('UI: RecipeManager login prompt', () => {
    it('shows login prompt when not logged in', () => {
      // Clear any stored auth
      cy.clearLocalStorage()
      cy.visit('/#/manage')
      cy.contains('登录后可管理配方').should('be.visible')
      cy.contains('登录 / 注册').should('be.visible')
    })
  })

  // -------------------------------------------------------------------------
  // API: Case-insensitive username registration
  // -------------------------------------------------------------------------
  describe('API: case-insensitive username registration', () => {
    const CASE_USER = 'CypressCaseTest'
    const CASE_PASS = 'test1234'

    // Cleanup before test
    before(() => {
      cy.request({ url: '/api/users', headers: authHeaders }).then(res => {
        const leftover = res.body.find(u =>
          u.username.toLowerCase() === CASE_USER.toLowerCase()
        )
        if (leftover) {
          cy.request({
            method: 'DELETE',
            url: `/api/users/${leftover.id || leftover._id}`,
            headers: authHeaders,
            failOnStatusCode: false,
          })
        }
      })
    })

    after(() => {
      // Cleanup registered user
      cy.request({ url: '/api/users', headers: authHeaders }).then(res => {
        const user = res.body.find(u =>
          u.username.toLowerCase() === CASE_USER.toLowerCase()
        )
        if (user) {
          cy.request({
            method: 'DELETE',
            url: `/api/users/${user.id || user._id}`,
            headers: authHeaders,
            failOnStatusCode: false,
          })
        }
      })
    })

    it('registers a user with mixed case', () => {
      cy.request({
        method: 'POST',
        url: '/api/register',
        body: { username: CASE_USER, password: CASE_PASS },
        failOnStatusCode: false,
      }).then(res => {
        expect(res.status).to.eq(201)
        expect(res.body.token).to.be.a('string')
      })
    })

    it('rejects registration with same username in different case', () => {
      cy.request({
        method: 'POST',
        url: '/api/register',
        body: { username: CASE_USER.toLowerCase(), password: CASE_PASS },
        failOnStatusCode: false,
      }).then(res => {
        expect(res.status).to.eq(400)
      })
    })

    it('rejects registration with all-uppercase variant', () => {
      cy.request({
        method: 'POST',
        url: '/api/register',
        body: { username: CASE_USER.toUpperCase(), password: CASE_PASS },
        failOnStatusCode: false,
      }).then(res => {
        expect(res.status).to.eq(400)
      })
    })

    it('allows case-insensitive login', () => {
      cy.request({
        method: 'POST',
        url: '/api/login',
        body: { username: CASE_USER.toLowerCase(), password: CASE_PASS },
        failOnStatusCode: false,
      }).then(res => {
        expect(res.status).to.eq(200)
        expect(res.body.token).to.be.a('string')
      })
    })
  })

  // -------------------------------------------------------------------------
  // API: One-time username change via PUT /api/me/username
  // -------------------------------------------------------------------------
  describe('API: one-time username change', () => {
    const RENAME_USER = 'cypress_rename_test'
    const RENAME_PASS = 'rename1234'
    let renameToken
    let renameUserId

    before(() => {
      // Cleanup leftovers
      cy.request({ url: '/api/users', headers: authHeaders }).then(res => {
        for (const name of [RENAME_USER, 'cypress_renamed']) {
          const leftover = res.body.find(u => u.username.toLowerCase() === name)
          if (leftover) {
            cy.request({
              method: 'DELETE',
              url: `/api/users/${leftover.id || leftover._id}`,
              headers: authHeaders,
              failOnStatusCode: false,
            })
          }
        }
      })
    })

    after(() => {
      // Cleanup
      if (renameUserId) {
        cy.request({
          method: 'DELETE',
          url: `/api/users/${renameUserId}`,
          headers: authHeaders,
          failOnStatusCode: false,
        })
      }
    })

    it('registers a user for rename test', () => {
      cy.request({
        method: 'POST',
        url: '/api/register',
        body: { username: RENAME_USER, password: RENAME_PASS },
      }).then(res => {
        expect(res.status).to.eq(201)
        renameToken = res.body.token

        // Get user ID
        cy.request({ url: '/api/users', headers: authHeaders }).then(listRes => {
          const u = listRes.body.find(x => x.username === RENAME_USER)
          renameUserId = u.id || u._id
        })
      })
    })

    it('GET /api/me returns username_changed=false initially', () => {
      cy.request({
        url: '/api/me',
        headers: { Authorization: `Bearer ${renameToken}` },
      }).then(res => {
        expect(res.status).to.eq(200)
        expect(res.body.username_changed).to.eq(false)
      })
    })

    it('renames username successfully the first time', () => {
      cy.request({
        method: 'PUT',
        url: '/api/me/username',
        headers: { Authorization: `Bearer ${renameToken}` },
        body: { username: 'cypress_renamed' },
      }).then(res => {
        expect(res.status).to.eq(200)
        expect(res.body.ok).to.eq(true)
        expect(res.body.username).to.eq('cypress_renamed')
      })
    })

    it('GET /api/me returns username_changed=true after rename', () => {
      cy.request({
        url: '/api/me',
        headers: { Authorization: `Bearer ${renameToken}` },
      }).then(res => {
        expect(res.body.username_changed).to.eq(true)
      })
    })

    it('rejects second rename attempt', () => {
      cy.request({
        method: 'PUT',
        url: '/api/me/username',
        headers: { Authorization: `Bearer ${renameToken}` },
        body: { username: 'cypress_another_name' },
        failOnStatusCode: false,
      }).then(res => {
        expect(res.status).to.eq(400)
      })
    })
  })

  // -------------------------------------------------------------------------
  // API: en_name auto-translation on recipe create (no explicit en_name)
  // -------------------------------------------------------------------------
  describe('API: en_name auto-translation on create', () => {
    let recipeId

    after(() => {
      if (recipeId) {
        cy.request({
          method: 'DELETE',
          url: `/api/recipes/${recipeId}`,
          headers: authHeaders,
          failOnStatusCode: false,
        })
      }
    })

    it('auto-translates en_name when creating recipe without en_name', () => {
      cy.request({
        method: 'POST',
        url: '/api/recipes',
        headers: authHeaders,
        body: {
          name: '排毒按摩',
          ingredients: [{ oil_name: '薰衣草', drops: 3 }],
          tags: [],
        },
      }).then(res => {
        expect(res.status).to.be.oneOf([200, 201])
        recipeId = res.body.id

        cy.request('/api/recipes').then(listRes => {
          const found = listRes.body.find(r => r.id === recipeId)
          expect(found).to.exist
          expect(found.en_name).to.be.a('string')
          expect(found.en_name.length).to.be.greaterThan(0)
          // auto_translate('排毒按摩') should produce 'Detox Massage'
          expect(found.en_name).to.include('Detox')
          expect(found.en_name).to.include('Massage')
        })
      })
    })
  })

  // -------------------------------------------------------------------------
  // API: Recipe name change auto-retranslates en_name
  // -------------------------------------------------------------------------
  describe('API: rename recipe auto-retranslates en_name', () => {
    let recipeId

    after(() => {
      if (recipeId) {
        cy.request({
          method: 'DELETE',
          url: `/api/recipes/${recipeId}`,
          headers: authHeaders,
          failOnStatusCode: false,
        })
      }
    })

    it('creates recipe with auto en_name, then renames to verify retranslation', () => {
      cy.request({
        method: 'POST',
        url: '/api/recipes',
        headers: authHeaders,
        body: {
          name: '助眠喷雾',
          ingredients: [{ oil_name: '薰衣草', drops: 5 }],
          tags: [],
        },
      }).then(res => {
        recipeId = res.body.id

        // Verify initial auto-translation
        cy.request('/api/recipes').then(listRes => {
          const r = listRes.body.find(x => x.id === recipeId)
          expect(r.en_name).to.include('Sleep')

          // Rename to completely different name
          cy.request({
            method: 'PUT',
            url: `/api/recipes/${recipeId}`,
            headers: authHeaders,
            body: { name: '肩颈按摩' },
          }).then(() => {
            cy.request('/api/recipes').then(list2 => {
              const r2 = list2.body.find(x => x.id === recipeId)
              // Should now be retranslated to Neck & Shoulder Massage
              expect(r2.en_name).to.include('Neck')
              expect(r2.en_name).to.include('Massage')
              // Should NOT contain Sleep anymore
              expect(r2.en_name).to.not.include('Sleep')
            })
          })
        })
      })
    })

    it('does not retranslate when explicit en_name provided on update', () => {
      cy.request({
        method: 'PUT',
        url: `/api/recipes/${recipeId}`,
        headers: authHeaders,
        body: { name: '免疫配方', en_name: 'my custom name' },
      }).then(() => {
        cy.request('/api/recipes').then(listRes => {
          const r = listRes.body.find(x => x.id === recipeId)
          expect(r.en_name).to.eq('My Custom Name') // title-cased
        })
      })
    })
  })

  // -------------------------------------------------------------------------
  // API: Delete user transfers diary to admin (with username appended)
  // -------------------------------------------------------------------------
  describe('API: delete user diary transfer with username', () => {
    const XFER_USER = 'cypress_xfer_test'
    const XFER_PASS = 'xfer1234'
    let xferUserId
    let xferToken

    before(() => {
      // Cleanup leftovers
      cy.request({ url: '/api/users', headers: authHeaders }).then(res => {
        const leftover = res.body.find(u => u.username === XFER_USER)
        if (leftover) {
          cy.request({
            method: 'DELETE',
            url: `/api/users/${leftover.id || leftover._id}`,
            headers: authHeaders,
            failOnStatusCode: false,
          })
        }
      })
    })

    it('registers user, adds diary, deletes user, verifies transfer', () => {
      // Register
      cy.request({
        method: 'POST',
        url: '/api/register',
        body: { username: XFER_USER, password: XFER_PASS },
      }).then(regRes => {
        xferToken = regRes.body.token

        // Get user id
        cy.request({ url: '/api/users', headers: authHeaders }).then(listRes => {
          const u = listRes.body.find(x => x.username === XFER_USER)
          xferUserId = u.id || u._id

          const userAuth = { Authorization: `Bearer ${xferToken}` }

          // Add unique diary entry
          cy.request({
            method: 'POST',
            url: '/api/diary',
            headers: userAuth,
            body: {
              name: 'PR28转移日记',
              ingredients: [
                { oil: '檀香', drops: 7 },
                { oil: '岩兰草', drops: 3 },
              ],
              note: '转移测试PR28',
            },
          }).then(() => {
            // Delete user
            cy.request({
              method: 'DELETE',
              url: `/api/users/${xferUserId}`,
              headers: authHeaders,
            }).then(delRes => {
              expect(delRes.body.ok).to.eq(true)

              // Verify diary was transferred to admin with username appended
              cy.request({
                url: '/api/diary',
                headers: authHeaders,
              }).then(diaryRes => {
                const transferred = diaryRes.body.find(
                  d => d.name && d.name.includes('PR28转移日记') && d.name.includes(XFER_USER)
                )
                expect(transferred).to.exist
                expect(transferred.note).to.eq('转移测试PR28')

                // Cleanup
                if (transferred) {
                  cy.request({
                    method: 'DELETE',
                    url: `/api/diary/${transferred.id}`,
                    headers: authHeaders,
                    failOnStatusCode: false,
                  })
                }
              })
            })
          })
        })
      })
    })
  })
})