it('should return specific error message', () => {
        const data = { label: 1234 };
        const schema = object().shape({
          region: string().required('A region is required.'),
        });

        return Request(setData(data, schema))
          .catch((response) => {
            expect(response.response.data.errors).toEqual([{
              field: 'region',
              reason: `A region is required.`,
            }]);
          });
      });

import { validateYupSchema, yupToFormErrors } from '../src';

const Yup = require('yup');
const schema = Yup.object().shape({
  name: Yup.string('Name must be a string').required('required'),
});

describe('Yup helpers', () => {
  describe('yupToFormErrors()', () => {
    it('should transform Yup ValidationErrors into an object', async () => {
      try {
        await schema.validate({}, { abortEarly: false });
      } catch (e) {
        expect(yupToFormErrors(e)).toEqual({
          name: 'required',
        });
      }
    });
  });

  describe('validateYupSchema()', () => {
    it('should validate', async () => {
      try {
        await validateYupSchema({}, schema);
      } catch (e) {
        expect(e.name).toEqual('ValidationError');
        expect(e.errors).toEqual(['required']);
      }
    });

    it('should stringify all values', async () => {

import { array, mixed, number, object, string } from 'yup';

export const importZoneSchema = object({
  domain: string().required('Domain is required.'),
  remote_nameserver: string().required('Remote nameserver is required.')
});

const domainSchemaBase = object().shape({
  domain: string()
    .matches(/([a-zA-Z0-9-_]+\.)+([a-zA-Z]{2,3}\.)?([a-zA-Z]{2,16}|XN--[a-zA-Z0-9]+)/, 'Domain is not valid.'),
  status: mixed().oneOf(['disabled', 'active', 'edit_mode', 'has_errors']),
  tags: array(),
  description: string()
    .min(1, 'Description must be between 1 and 255 characters.')
    .max(255, 'Description must be between 1 and 255 characters.'),
  retry_sec: number(),
  master_ips: array().of(string()),
  axfr_ips: array().of(string()),
  expire_sec: number(),
  refresh_sec: number(),
  ttl_sec: number()
});

export const createDomainSchema = domainSchemaBase.shape({
  domain: string()
    .required('Domain is required.')
    .matches(/([a-zA-Z0-9-_]+\.)+([a-zA-Z]{2,3}\.)?([a-zA-Z]{2,16}|XN--[a-zA-Z0-9]+)/, 'Domain is not valid.'),
  type: mixed()
    .required()
    .oneOf(['master', 'slave']),
  soa_email: string()

import { array, boolean, number, object, string } from 'yup';

export const updateIPSchema = object().shape({
  rdns: string()
    .notRequired()
    .nullable(true)
});

export const allocateIPSchema = object().shape({
  type: string()
    .required()
    .matches(
      /^ipv4$/,
      'Only IPv4 address may be allocated through this endpoint.'
    ),
  public: boolean().required(),
  linode_id: number().required()
});

export const assignAddressesSchema = object().shape({
  region: string().required(),
  assignments: array()
    .of(object())
    .required()
});

export const shareAddressesSchema = object().shape({
  linode_id: number().required(),
  ips: array().of(string())
});

import { array, boolean, mixed, number, object, string } from 'yup';

import { NodeBalancerConfigFields } from './configs';

export const nodeBalancerConfigNodeSchema = object({
  label: string()
    .matches(/^[a-z0-9-_]+$/, "Label can't contain special characters, uppercase characters, or whitespace.")
    .min(3, 'Label should be between 3 and 32 characters.')
    .max(32, 'Label should be between 3 and 32 characters.')
    .required('Label is required.'),


  address: string()
    .matches(/^192\.168\.\d{1,3}\.\d{1,3}$/, 'Must be a valid IPv4 address.')
    .required('IP address is required.'),

  port: number().typeError("Port must be a number.")
    .required('Port is required.')
    .min(1, "Port must be between 1 and 65535.")
    .max(65535, "Port must be between 1 and 65535."),

  weight: number().typeError("Weight must be a number.")
    .min(1, `Weight must be between 1 and 255.`)
    .max(255, `Weight must be between 1 and 255.`),

  mode: mixed()
    .oneOf(['accept', 'reject', 'drain'])
});

export const createNodeBalancerConfigSchema = object({
  algorithm: mixed().oneOf(["roundrobin", "leastconn", "source"]),
  check_attempts: number(),

import { number, object, string } from 'yup';

export const createImageSchema = object().shape({
  disk_id: number()
    .typeError('Disk is required.')
    .required('Disk is required.'),
  label: string()
    .notRequired()
    .max(50, 'Length must be 50 characters or less.')
    .matches(/^[a-zA-Z0-9,.?\-_\s']+$/, 'Image labels cannot contain special characters.'),
  description: string()
    .notRequired()
    .min(1)
    .max(65000)
});

export const updateImageSchema = object().shape({
  label: string()
    .notRequired()
    .max(50, 'Length must be 50 characters or less.')
    .matches(/^[a-zA-Z0-9,.?\-_\s']+$/, 'Image labels cannot contain special characters.'),
  description: string()
    .notRequired()
    .max(65000, 'Length must be 65000 characters or less.')
});

export const ResizeVolumeSchema = (minSize: number = 10) => object({
  size: createSizeValidation(minSize),
})

import * as Yup from 'yup'

export const mappingValidationSchema = Yup.object().shape({
    method: Yup.string()
        .required('Request method is required'),
    queryParameters: Yup.array().of(Yup.object().shape({
        key: Yup.string()
            .required('Query parameter name is required'),
        value: Yup.string()
            .required('Query parameter value is required'),
    })),
    requestHeaders: Yup.array().of(Yup.object().shape({
        key: Yup.string()
            .required('Header name is required'),
        value: Yup.string()
            .required('Header value is required'),
    })),
    requestCookies: Yup.array().of(Yup.object().shape({
        key: Yup.string()
            .required('Cookie name is required'),
        value: Yup.string()
            .required('Cookie value is required'),
    })),
    responseStatus: Yup.number()
        .min(100, 'Response status code is invalid')
        .max(527, 'Response status code is invalid')
        .required('Response status code is required'),
    responseHeaders: Yup.array().of(Yup.object().shape({
        key: Yup.string()
            .required('Header name is required'),
        value: Yup.string()

import { array, boolean, number, object, string } from 'yup';

export const updateIPSchema = object().shape({
  rdns: string().notRequired().nullable(true)
});

export const allocateIPSchema = object().shape({
  type: string()
    .required()
    .matches(/^ipv4$/, 'Only IPv4 address may be allocated through this endpoint.'),
  public: boolean().required(),
  linode_id: number().required()
});

export const assignAddressesSchema = object().shape({
  region: string().required(),
  assignments: array().of(object()).required()
});

export const shareAddressesSchema = object().shape({
  linode_id: number().required(),
  ips: array().of(string())
});

  number()
    .integer()
    .typeError(`Size must be a number`)
    .min(minSize, `Size must be between ${minSize} and ${MAX_VOLUME_SIZE}.`)
    .max(MAX_VOLUME_SIZE, `Size must be between ${minSize} and ${MAX_VOLUME_SIZE}.`)
    .required(`A size is required.`);

export const CreateVolumeSchema = object({
  region: string()
    .when('linode_id', {
      is: (id) => id === undefined || id === '',
      then: string().required("Must provide a region or a Linode ID."),
    }),
  linode_id: number(),
  size: createSizeValidation(10),
  label: string()
    .required("Label is required.")
    .ensure()
    .trim()
    .min(1, "Label must be between 1 and 32 characters.")
    .max(32, "Label must be 32 characters or less."),
  config_id: number().typeError("Config ID must be a number."),
  tags: array().of(string())
});

export const CloneVolumeSchema = object({
  label: string().required()
})

export const ResizeVolumeSchema = (minSize: number = 10) => object({
  size: createSizeValidation(minSize),

import { object, string } from 'yup';

export const CreateBucketSchema = object({
  label: string()
    .required('Label is required.')
    .ensure()
    .trim()
    // @todo: What are the actual limits?
    .min(3, 'Label must be between 3 and 32 characters.')
    .max(32, 'Label must be 32 characters or less.'),
  cluster: string().required('Cluster is required.')
});

import { array, boolean, mixed, number, object, string } from 'yup';
// import * as zxcvbn from 'zxcvbn';

const stackscript_data = array().of(object()).nullable(true);

/* @todo add more comprehensive validation.
*  First validate password using the regex used by the API. Then make sure the password also has a zxcvbn score >= 3.
*  Only run validation tests if image is provided (as otherwise the value passed is an empty string, which will fail
*  validation.)
*/
// const root_pass_disk = string()
//   .when('image', {
//     is: (value) => Boolean(value),
//     then: string().required("You must provide a root password when deploying from an image.")
//       .min(6, "Password must be between 6 and 128 characters.")
//       .max(128, "Password must be between 6 and 128 characters.")
//       .matches(/^(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9]))|((?=.*[a-z])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\]))|((?=.*[A-Z])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\]))|((?=.*[0-9])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\])))/,
//         "Password must contain at least 2 of the following classes: uppercase letters, lowercase letters, numbers, and punctuation.")
//       .test('is-strong-password', 'Please choose a stronger password.', (value: string) => zxcvbn(value).score > 3),
//     otherwise: string().notRequired()
//   });

export const ResizeLinodeDiskSchema = object({
  size: number().required().min(1),
});

export const CreateLinodeSchema = object({
  type: string()
    .ensure()
    .required('Plan is required.'),
  region: string()

import { array, boolean, mixed, number, object, string } from 'yup';
// import * as zxcvbn from 'zxcvbn';

const stackscript_data = array()
  .of(object())
  .nullable(true);

/* @todo add more comprehensive validation.
 *  First validate password using the regex used by the API. Then make sure the password also has a zxcvbn score >= 3.
 *  Only run validation tests if image is provided (as otherwise the value passed is an empty string, which will fail
 *  validation.)
 */
// const root_pass_disk = string()
//   .when('image', {
//     is: (value) => Boolean(value),
//     then: string().required("You must provide a root password when deploying from an image.")
//       .min(6, "Password must be between 6 and 128 characters.")
//       .max(128, "Password must be between 6 and 128 characters.")
//       .matches(/^(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9]))|((?=.*[a-z])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\]))|((?=.*[A-Z])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\]))|((?=.*[0-9])(?=.*[!"#$%&'()*+,-.\/:;<=>?@\[\]^_`{|}~\\])))/,
//         "Password must contain at least 2 of the following classes: uppercase letters, lowercase letters, numbers, and punctuation.")
//       .test('is-strong-password', 'Please choose a stronger password.', (value: string) => zxcvbn(value).score > 3),
//     otherwise: string().notRequired()
//   });

export const ResizeLinodeDiskSchema = object({
  size: number()
    .required()
    .min(1)
});

export const CreateLinodeSchema = object({

import * as yup from 'yup';
import { setLocale } from 'yup/lib/customLocale';

// tslint:disable-next-line:no-duplicate-imports
import { reach, date, Schema, ObjectSchema, ValidationError, MixedSchema, SchemaDescription, TestOptions, ValidateOptions, NumberSchema } from 'yup';

// reach function
let schema = yup.object().shape({
    nested: yup.object().shape({
        arr: yup.array().of(
            yup.object().shape({ num: yup.number().max(4) })
        )
    })
  });
reach(schema, 'nested.arr.num');
reach(schema, 'nested.arr[].num');

// addMethod function
yup.addMethod<NumberSchema>(yup.number, 'minimum', function(this, minValue: number, message: string) {
    return this.min(minValue, message);
});
yup.addMethod(yup.date, 'newMethod', function(this: yup.DateSchema, date: Date, message?: string) {
    return this.max(date, message);
});

// ref function
schema = yup.object().shape({
    baz: yup.ref('foo.bar'),
    foo: yup.object().shape({
      bar: yup.string()
    }),

import { object, string } from 'yup';

export const enableTwoFactorSchema = object({
  tfa_code: string().required('Please enter a token.')
});

import { number, object, string } from 'yup';

const recordBaseSchema = object().shape({
  name: string()
    .max(100, 'Record name must be 100 characters or less.'),
  target: string(),
  priority: number()
    .min(0, 'Priority must be between 0 and 255.')
    .max(255, 'Priority must be between 1 and 255.'),
  weight: number(),
  port: number(),
  service: string().nullable(true),
  protocol: string().nullable(true),
  ttl_sec: number(),
  tag: string()
});

const validRecordTypes: string[] = ['A', 'AAAA', 'NS', 'MX', 'CNAME', 'TXT', 'SRV', 'PTR', 'CAA'];

export const createRecordSchema = recordBaseSchema.shape({
  type: string()
    .required('Type is required.')
    .oneOf(validRecordTypes),
});

export const updateRecordSchema = recordBaseSchema.shape({
  type: string()
    .oneOf(validRecordTypes),
});

import { number, object, string } from 'yup';

export const createSupportTicketSchema = object({
  summary: string()
    .required('Summary is required.')
    .min(1, 'Summary must be between 1 and 64 characters.')
    .max(64, 'Summary must be between 1 and 64 characters.')
    .trim(),
  description: string()
    .required('Description is required.')
    .min(1, 'Description must be between 1 and 64,000 characters.')
    .max(64000, 'Description must be between 1 and 64,000 characters.')
    .trim(),
  domain_id: number(),
  linode_id: number(),
  longviewclient_id: number(),
  nodebalancer_id: number(),
  volume_id: number(),
});

export const createReplySchema = object({
  description: string()
    .required('Description is required.')
    .min(1, 'Description must be between 1 and 65,535 characters.')
    .max(65535, 'Description must be between 1 and 65,535 characters.')
    .trim()
});

import { array, boolean, object, string } from 'yup';

export const stackScriptSchema = object({
  script: string().required('Script is required.'),
  label: string()
    .required('Label is required.')
    .min(3, 'Label must be between 3 and 128 characters.')
    .max(128, 'Label must be between 3 and 128 characters.'),
  images: array()
    .of(string())
    .required('An image is required.'),
  description: string(),
  is_public: boolean(),
  rev_note: string()
});

export const updateStackScriptSchema = object({
  script: string(),
  label: string()
    .min(3, 'Label must be between 3 and 128 characters.')
    .max(128, 'Label must be between 3 and 128 characters.'),
  images: array()
    .of(string())
    .min(1, 'An image is required.'),
  description: string(),
  is_public: boolean(),
  rev_note: string()
});

import * as Yup from "yup";

export const UserRules = {
    email: Yup.string()
        .email("Invalid email address")
        .required("Email is required!"),
    password: Yup.string().required("Password is required!"),
};

export const PriceListRules = {
    item: Yup.object()
        .nullable(true)
        .required("Item is required"),
    name: Yup.string().required("Name is required"),
    quantity: Yup.number()
        .integer()
        .required("Quantity is required")
        .moreThan(0, "Quantity must be greater than zero"),
    slug: Yup.string()
        .min(4)
        .matches(/^[a-z|0-9|_|\-]+$/, "Slug must be a-z, 0-9, or underscore")
        .required("Slug is required"),
};

export const PostRules = {
    body: Yup.string().required("Post body is required"),
    slug: Yup.string()
        .min(4)
        .matches(/^[a-z|0-9|_|\-]+$/, "Slug must be a-z, 0-9, or underscore")
        .required("Slug is required"),
    summary: Yup.string().required("Post summary is required"),

import { array, boolean, object, string } from 'yup';

export const createPersonalAccessTokenSchema = object({
  scopes: string(),
  expiry: string(),
  label: string()
    .min(1, 'Label must be between 1 and 100 characters.')
    .max(100, 'Label must be between 1 and 100 characters.')
});

export const createSSHKeySchema = object({
  label: string()
    .required('Label is required.')
    .min(1, 'Label must be between 1 and 64 characters.')
    .max(64, 'Label must be between 1 and 64 characters.')
    .trim(),
  ssh_key: string()
});

export const updateProfileSchema = object({
  email: string().email(),
  timezone: string(),
  email_notifications: boolean(),
  authorized_keys: array().of(string()),
  restricted: boolean(),
  two_factor_auth: boolean(),
  lish_auth_method: string().oneOf(['password_keys', 'keys_only', 'disabled'])
});