public void ConstructorTest()
        {
            var err = new Recurly.Resources.ErrorMayHaveTransaction()
            {
                Message = "Something bad happened"
            };
            var ex = new MyApiError(err.Message)
            {
                Error = err
            };

            Assert.Equal(err.Message, ex.Message);
            Assert.Equal(err, ex.Error);
        }
        public static ApiError Create(Recurly.Resources.ErrorMayHaveTransaction err)
        {
            switch (err.Type)
            {
            case "bad_request":
                return(new BadRequest(err.Message)
                {
                    Error = err
                });

            case "internal_server_error":
                return(new InternalServer(err.Message)
                {
                    Error = err
                });

            case "immutable_subscription":
                return(new ImmutableSubscription(err.Message)
                {
                    Error = err
                });

            case "invalid_api_key":
                return(new InvalidApiKey(err.Message)
                {
                    Error = err
                });

            case "invalid_api_version":
                return(new InvalidApiVersion(err.Message)
                {
                    Error = err
                });

            case "invalid_content_type":
                return(new InvalidContentType(err.Message)
                {
                    Error = err
                });

            case "invalid_permissions":
                return(new InvalidPermissions(err.Message)
                {
                    Error = err
                });

            case "invalid_token":
                return(new InvalidToken(err.Message)
                {
                    Error = err
                });

            case "not_found":
                return(new NotFound(err.Message)
                {
                    Error = err
                });

            case "simultaneous_request":
                return(new SimultaneousRequest(err.Message)
                {
                    Error = err
                });

            case "transaction":
                return(new Transaction(err.Message)
                {
                    Error = err
                });

            case "unauthorized":
                return(new Unauthorized(err.Message)
                {
                    Error = err
                });

            case "unavailable_in_api_version":
                return(new UnavailableInApiVersion(err.Message)
                {
                    Error = err
                });

            case "unknown_api_version":
                return(new UnknownApiVersion(err.Message)
                {
                    Error = err
                });

            case "validation":
                return(new Validation(err.Message)
                {
                    Error = err
                });

            case "missing_feature":
                return(new MissingFeature(err.Message)
                {
                    Error = err
                });

            default:
                // Explode if we are in strict mode
                if (Utils.StrictMode)
                {
                    throw new ArgumentException($"{err.Type} has no valid exception class");
                }
                // Fall back to generic API error if we are in production
                else
                {
                    return(new ApiError(err.Message)
                    {
                        Error = err
                    });
                }
            }
        }