/* @lint test files are fine to be longer */
/* eslint max-lines: "OFF" */
import {
  loginBaseURL,
  logoutBaseUrl,
  registerBaseUrl,
  addaddressBaseUrl,
  addcardBaseUrl,
  deletecardBaseUrl,
  updatePasswordUrl,
  addSecurityQuestionUrl,
  getProfileUrl,
  updateProfileUrl,
  resetPasswordByMailUrl,
  validateResetEmailUrl,
  validateResetSMSUrl,
  getSecurityQuestionUrl,
  resetPasswordBySQUrl,
  campaignId,
  appid,
  locale,
} from '../../bootstrapper/api/config'
import { Request } from '@skava/request'
import {
  register,
  login,
  getProfile,
  updatePassword,
  updateProfile,
  addAddress,
  removeAddress,
  updateAddress,
  changeDefaultAddress,
  addCard,
  deleteCard,
  changeDefaultCard,
  addSecurityQuestion,
  resetPasswordBySMS,
  validateResetPasswordBySMS,
  validateResetPasswordByEmail,
  resetPasswordByEmail,
  resetPasswordBySecurityQuestions,
  getSecurityQuestions,
  logout,
} from './requests.POST'
import {
  loginParams,
  registerParams,
  logoutParams,
  addAddressParams,
  removeAddressParams,
  updateAddressParams,
  changeDefaultAddressParams,
  addCardParams,
  deleteCardParams,
  changeDefaultCardParams,
  getProfileParams,
  updateProfileParams,
  updatePasswordParams,
  addSecurityQuestionParams,
  resetPasswordByEmailParams,
  validateResetPasswordByEmailParams,
  resetPasswordBySMSParams,
  validateResetPasswordBySMSParams,
  getSecurityQuestionsParams,
  resetPasswordBySecurityQuestionsParams,
} from './defaultParams'
import {
  addAddressSuccessFixture,
  addCardSuccessFixture,
  deleteCardSuccessFixture,
  loginSuccessFixture,
  logoutSuccessFixture,
  registerSuccessFixture,
  userUpdateSuccessFixture,
  passwordUpdateSuccessFixture,
  resetPasswordByEmailSuccessFixture,
  validateEmailFixture,
  validateSmsFixture,
  validateSQFixture,
  profileSuccessFixture,
  getSecurityQuestionSuccessFixture,
  resetPasswordBySecurityQuestionSuccessFixture,
} from './fixtures'

// test('Register user', async() => {
//   const chain = new Request()
//     .path(registerBaseUrl)
//     .tapResponseData(registerSuccessFixture)
//     .tapRequestParams(registerParams)
//   const nock = chain.toMock()
//   const request = chain.toRequest()
//   const data = await request()

//   require('fliplog').registerCatch().quick({
//     data,
//     nock,
//     request,
//   })
//   expect(typeof nock).toBe('object')
// })

test('Login user', async () => {
  const request = new Request()
    .path(loginBaseURL)
    .tapResponseData(loginSuccessFixture)
    .tapRequestParams(loginParams)
    .toMock()
  const loginSuccessData = await request
  expect(typeof loginSuccessData).toBe('object')
})

test('Logout user', async () => {
  const request = new Request()
    .path(logoutBaseUrl)
    .tapResponseData(logoutSuccessFixture)
    .tapRequestParams(logoutParams)
    .toMock()
  const logoutSuccessData = await request
  expect(typeof logoutSuccessData).toBe('object')
})

test('Add shipping address', async () => {
  const request = new Request()
    .path(addaddressBaseUrl)
    .tapResponseData(addAddressSuccessFixture)
    .tapRequestParams(addAddressParams)
    .toMock()
  const addAddressSuccessData = await request
  expect(typeof addAddressSuccessData).toBe('object')
})

test('Remove shipping address', async () => {
  const request = new Request()
    .path(addaddressBaseUrl)
    .tapResponseData(addAddressSuccessFixture)
    .tapRequestParams(removeAddressParams)
    .toMock()
  const removeAddressSuccessData = await request
  expect(typeof removeAddressSuccessData).toBe('object')
})

test('Update shipping address', async () => {
  const request = new Request()
    .path(addaddressBaseUrl)
    .tapResponseData(userUpdateSuccessFixture)
    .tapRequestParams(updateAddressParams)
    .toMock()
  const updateAddressSuccessData = await request
  expect(typeof updateAddressSuccessData).toBe('object')
})

test('Change Default shipping address', async () => {
  const request = new Request()
    .path(addaddressBaseUrl)
    .tapResponseData(userUpdateSuccessFixture)
    .tapRequestParams(changeDefaultAddressParams)
    .toMock()
  const changeDefaultAddressSuccessData = await request
  expect(typeof changeDefaultAddressSuccessData).toBe('object')
})

test('Add payment card', async () => {
  const request = new Request()
    .path(addcardBaseUrl)
    .tapResponseData(addCardSuccessFixture)
    .tapRequestParams(addCardParams)
    .toMock()
  const cardAddSuccessData = await request
  expect(typeof cardAddSuccessData).toBe('object')
})

test('Delete payment card', async () => {
  const request = new Request()
    .path(deletecardBaseUrl)
    .tapResponseData(deleteCardSuccessFixture)
    .tapRequestParams(deleteCardParams)
    .toMock()
  const cardDeleteSuccessData = await request
  expect(typeof cardDeleteSuccessData).toBe('object')
})

test('Change default payment card', async () => {
  const request = new Request()
    .path(addcardBaseUrl)
    .tapResponseData(userUpdateSuccessFixture)
    .tapRequestParams(changeDefaultCardParams)
    .toMock()
  const changeDefaultCardSuccessData = await request
  expect(typeof changeDefaultCardSuccessData).toBe('object')
})

test('Get profile data', async () => {
  const request = new Request()
    .path(getProfileUrl)
    .tapResponseData(profileSuccessFixture)
    .tapRequestParams(getProfileParams)
    .toMock()
  const getProfileSuccessData = await request
  expect(typeof getProfileSuccessData).toBe('object')
})

test('Update profile', async () => {
  const request = new Request()
    .path(updateProfileUrl)
    .tapResponseData(userUpdateSuccessFixture)
    .tapRequestParams(updateProfileParams)
    .toMock()
  const getProfileSuccessData = await request
  expect(typeof getProfileSuccessData).toBe('object')
})

test('Update password', async () => {
  const request = new Request()
    .path(updatePasswordUrl)
    .tapResponseData(passwordUpdateSuccessFixture)
    .tapRequestParams(updatePasswordParams)
    .toMock()
  const updatePasswordSuccessData = await request
  expect(typeof updatePasswordSuccessData).toBe('object')
})

test('Add / Change security question', async () => {
  const request = new Request()
    .path(addSecurityQuestionUrl)
    .tapResponseData(userUpdateSuccessFixture)
    .tapRequestParams(addSecurityQuestionParams)
    .toMock()
  const addSecurityQuestionSuccessData = await request
  expect(typeof addSecurityQuestionSuccessData).toBe('object')
})

test('Reset password by email', async () => {
  const request = new Request()
    .path(resetPasswordByMailUrl)
    .tapResponseData(resetPasswordByEmailSuccessFixture)
    .tapRequestParams(resetPasswordByEmailParams)
    .toMock()
  const resetPasswordbyEmailSuccessData = await request
  expect(typeof resetPasswordbyEmailSuccessData).toBe('object')
})

test('Validate Reset password by email', async () => {
  const request = new Request()
    .path(validateResetEmailUrl)
    .tapResponseData(validateEmailFixture)
    .tapRequestParams(validateResetPasswordByEmailParams)
    .toMock()
  const validateResetPasswordbyEmailSuccessData = await request
  expect(typeof validateResetPasswordbyEmailSuccessData).toBe('object')
})

test('Reset password by SMS', async () => {
  const request = new Request()
    .path(resetPasswordByMailUrl)
    .tapResponseData(resetPasswordByEmailSuccessFixture)
    .tapRequestParams(resetPasswordBySMSParams)
    .toMock()
  const resetPasswordbySMSSuccessData = await request
  expect(typeof resetPasswordbySMSSuccessData).toBe('object')
})

test('Validate Reset password by SMS', async () => {
  const request = new Request()
    .path(validateResetSMSUrl)
    .tapResponseData(validateSmsFixture)
    .tapRequestParams(validateResetPasswordBySMSParams)
    .toMock()
  const validateResetPasswordbySMSSuccessData = await request
  expect(typeof validateResetPasswordbySMSSuccessData).toBe('object')
})

test('Get security question', async () => {
  const request = new Request()
    .path(getSecurityQuestionUrl)
    .tapResponseData(getSecurityQuestionSuccessFixture)
    .tapRequestParams(getSecurityQuestionsParams)
    .toMock()
  const getSecurityQuestionSuccessData = await request
  expect(typeof getSecurityQuestionSuccessData).toBe('object')
})

test('Reset password using security question', async () => {
  const request = new Request()
    .path(resetPasswordBySQUrl)
    .tapResponseData(resetPasswordBySecurityQuestionSuccessFixture)
    .tapRequestParams(resetPasswordBySecurityQuestionsParams)
    .toMock()
  const resetPasswordBySQSuccessData = await request
  expect(typeof resetPasswordBySQSuccessData).toBe('object')
})