1 files changed, 139 insertions, 0 deletions
diff --git a/t/exceptions/moose-meta-typeconstraint.t b/t/exceptions/moose-meta-typeconstraint.t
new file mode 100644
index 0000000..71e87d1
--- /dev/null
+++ b/t/exceptions/moose-meta-typeconstraint.t
@@ -0,0 +1,139 @@
+use strict;
+use warnings;
+
+use Test::More;
+use Test::Fatal;
+
+use Moose::Util::TypeConstraints;
+use Moose();
+
+# tests for type coercions
+{
+    subtype 'HexNum' => as 'Int', where { /[a-f0-9]/i };
+    my $type_object = find_type_constraint 'HexNum';
+
+    my $exception = exception {
+        $type_object->coerce;
+    };
+
+    like(
+        $exception,
+        qr/Cannot coerce without a type coercion/,
+        "You cannot coerce a type unless coercion is supported by that type");
+
+    is(
+        $exception->type_name,
+        'HexNum',
+        "You cannot coerce a type unless coercion is supported by that type");
+
+    isa_ok(
+        $exception,
+        "Moose::Exception::CoercingWithoutCoercions",
+        "You cannot coerce a type unless coercion is supported by that type");
+}
+
+{
+    my $exception = exception {
+        Moose::Meta::TypeConstraint->new( message => "foo");
+    };
+
+    like(
+        $exception,
+        qr/The 'message' parameter must be a coderef/,
+        "'foo' is not a CODE ref");
+
+    isa_ok(
+        $exception,
+        "Moose::Exception::MessageParameterMustBeCodeRef",
+        "'foo' is not a CODE ref");
+}
+
+{
+    subtype 'NotInlinable',
+        as 'Str',
+        where { $_ !~ /Q/ };
+    my $not_inlinable = find_type_constraint('NotInlinable');
+
+    my $exception = exception {
+        $not_inlinable->_inline_check('$foo');
+    };
+
+    like(
+        $exception,
+        qr/Cannot inline a type constraint check for NotInlinable/,
+        "cannot inline NotInlinable");
+
+    isa_ok(
+        $exception,
+        "Moose::Exception::CannotInlineTypeConstraintCheck",
+        "cannot inline NotInlinable");
+
+    is(
+        $exception->type_name,
+        "NotInlinable",
+        "cannot inline NotInlinable");
+
+    is(
+        find_type_constraint( $exception->type_name ),
+        $not_inlinable,
+        "cannot inline NotInlinable");
+}
+
+{
+    my $exception = exception {
+        Moose::Meta::TypeConstraint->new(name => "FooTypeConstraint", constraint => undef)
+    };
+
+    like(
+        $exception,
+        qr/Could not compile type constraint 'FooTypeConstraint' because no constraint check/,
+        "constraint is set to undef");
+
+    isa_ok(
+        $exception,
+        "Moose::Exception::NoConstraintCheckForTypeConstraint",
+        "constraint is set to undef");
+
+    is(
+        $exception->type_name,
+        "FooTypeConstraint",
+        "constraint is set to undef");
+}
+
+{
+    subtype 'OnlyPositiveInts',
+        as 'Int',
+        where { $_ > 1 };
+    my $onlyposint = find_type_constraint('OnlyPositiveInts');
+
+    my $exception = exception {
+        $onlyposint->assert_valid( -123 );
+    };
+
+    like(
+        $exception,
+        qr/Validation failed for 'OnlyPositiveInts' with value -123/,
+        "-123 is not valid for OnlyPositiveInts");
+
+    isa_ok(
+        $exception,
+        "Moose::Exception::ValidationFailedForTypeConstraint",
+        "-123 is not valid for OnlyPositiveInts");
+
+    is(
+        $exception->type->name,
+        "OnlyPositiveInts",
+        "-123 is not valid for OnlyPositiveInts");
+
+    is(
+        $exception->type,
+        $onlyposint,
+        "-123 is not valid for OnlyPositiveInts");
+
+    is(
+        $exception->value,
+        -123,
+        "-123 is not valid for OnlyPositiveInts");
+}
+
+done_testing;