diff --git a/lib/MetaCPAN/Role/Script.pm b/lib/MetaCPAN/Role/Script.pm
index 102f80174..c894fc42c 100644
--- a/lib/MetaCPAN/Role/Script.pm
+++ b/lib/MetaCPAN/Role/Script.pm
@@ -405,6 +405,9 @@ After C<await> seconds the Application will fail with an Exception and the Exit
 
     bin/metacpan <script_name> --await 15
 
+B<Exit Code:> If the I<ElasticSearch> service does not become available
+within C<await> seconds it exits the Script with Exit Code C< 112 >.
+
 See L<Method C<await()>>
 
 =back
@@ -425,7 +428,12 @@ Exception from the C<Search::Elasticsearch::Client> and sets C< $! > to C< 112 >
 The C<Search::Elasticsearch::Client> generates a C<"Search::Elasticsearch::Error::NoNodes"> Exception.
 When the service is available it will populate the C<cluster_info> C<HASH> structure with the basic information
 about the cluster.
+
+B<Exceptions:> It will throw an exceptions when the I<ElasticSearch> service does not become available
+within C<arg_await_timeout> seconds (as described above).
+
 See L<Option C<--await 15>>
+
 See L<Method C<check_health()>>
 
 =item C<check_health( [ refresh ] )>
@@ -443,6 +451,13 @@ The method returns C< 1 > when the C<cluster_info> is populated, none of the ind
 the Health State I<red> and at least one alias is created in C<aliases_info>
 otherwise the method returns C< 0 >
 
+B<Parameters:>
+
+C<refresh> - Integer evaluated as boolean when set to C< 1 > the cluster info structures
+will always be updated.
+
+See L<Method C<await()>>
+
 =item C<are_you_sure()>
 
 Requests the user to confirm the operation with "I< YES >"
diff --git a/lib/MetaCPAN/Script/Mapping.pm b/lib/MetaCPAN/Script/Mapping.pm
index 71c4f41fd..ba5452276 100644
--- a/lib/MetaCPAN/Script/Mapping.pm
+++ b/lib/MetaCPAN/Script/Mapping.pm
@@ -29,6 +29,13 @@ use constant {
 
 with 'MetaCPAN::Role::Script', 'MooseX::Getopt';
 
+has cpan_index => (
+    is            => 'ro',
+    isa           => Str,
+    default       => 'cpan_v1_01',
+    documentation => 'real name for the cpan index',
+);
+
 has arg_deploy_mapping => (
     init_arg      => 'delete',
     is            => 'ro',
@@ -37,6 +44,14 @@ has arg_deploy_mapping => (
     documentation => 'delete index if it exists already',
 );
 
+has arg_verify_mapping => (
+    init_arg      => 'verify',
+    is            => 'ro',
+    isa           => Bool,
+    default       => 0,
+    documentation => 'verify deployed index structure against definition',
+);
+
 has arg_list_types => (
     init_arg      => 'list_types',
     is            => 'ro',
@@ -133,6 +148,7 @@ sub run {
 
     if ( $self->await ) {
         $self->delete_index if $self->arg_delete_index;
+        $self->create_index if $self->arg_create_index;
         $self->update_index if $self->arg_update_index;
         $self->copy_type    if $self->copy_to_index;
         $self->empty_type   if $self->delete_from_type;
@@ -145,6 +161,19 @@ sub run {
             }
         }
 
+        if ( $self->arg_verify_mapping ) {
+            $self->check_health;
+            unless (
+                $self->mappings_valid(
+                    $self->_build_mapping, $self->_build_aliases
+                )
+                )
+            {
+                $self->print_error("Indices Verification has failed!");
+                $self->exit_code(1);
+            }
+        }
+
         if ( $self->arg_cluster_info ) {
             $self->check_health;
             $self->show_info;
@@ -152,7 +181,7 @@ sub run {
     }
 
 # The run() method is expected to communicate Success to the superior execution level
-    return ( $self->exit_code == 0 );
+    return ( $self->exit_code == 0 ? 1 : 0 );
 }
 
 sub _check_index_exists {
@@ -161,12 +190,18 @@ sub _check_index_exists {
 
     if ( $exists and !$expected ) {
         log_error {"Index already exists: $name"};
-        exit 0;
+
+        #Set System Error: 1 - EPERM - Operation not permitted
+        $self->exit_code(1);
+        $self->handle_error( "Conflicting index: $name", 1 );
     }
 
     if ( !$exists and $expected ) {
         log_error {"Index doesn't exists: $name"};
-        exit 0;
+
+        #Set System Error: 1 - EPERM - Operation not permitted
+        $self->exit_code(1);
+        $self->handle_error( "Missing index: $name", 1 );
     }
 }
 
@@ -208,7 +243,7 @@ sub update_index {
     for my $type ( sort keys %{$mapping} ) {
         log_info {"Adding mapping to index: $type"};
         $self->es->indices->put_mapping(
-            index => $self->index->name,
+            index => $name,
             type  => $type,
             body  => { $type => $mapping->{$type} },
         );
@@ -404,16 +439,10 @@ sub show_info {
     print JSON->new->utf8->pretty->encode($info_rs);
 }
 
-sub deploy_mapping {
-    my $self       = shift;
-    my $cpan_index = 'cpan_v1_01';
-    my $imappingok = 0;
-
-    $self->are_you_sure(
-        'this will delete EVERYTHING and re-create the (empty) indexes');
-
-    my %mappings = (
-        $cpan_index => {
+sub _build_mapping {
+    my $self = $_[0];
+    return {
+        $self->cpan_index => {
             author =>
                 decode_json(MetaCPAN::Script::Mapping::CPAN::Author::mapping),
             distribution => decode_json(
@@ -449,7 +478,24 @@ sub deploy_mapping {
         cover => {
             cover => decode_json(MetaCPAN::Script::Mapping::Cover::mapping),
         },
-    );
+    };
+}
+
+sub _build_aliases {
+    my $self = $_[0];
+    return { 'cpan' => $self->cpan_index };
+
+}
+
+sub deploy_mapping {
+    my $self       = shift;
+    my $is_mapping_ok = 0;
+
+    $self->are_you_sure(
+        'this will delete EVERYTHING and re-create the (empty) indexes');
+
+    # Deserialize the Index Mapping Structure
+    my $rmappings = $self->_build_mapping;
 
     my $deploy_statement
         = decode_json(MetaCPAN::Script::Mapping::DeployStatement::mapping);
@@ -458,105 +504,336 @@ sub deploy_mapping {
 
     # recreate the indices and apply the mapping
 
-    for my $idx ( sort keys %mappings ) {
+    for my $idx ( sort keys %$rmappings ) {
         $self->_delete_index($idx) if $es->indices->exists( index => $idx );
 
         log_info {"Creating index: $idx"};
         $es->indices->create( index => $idx, body => $deploy_statement );
 
-        for my $type ( sort keys %{ $mappings{$idx} } ) {
+        for my $type ( sort keys %{ $rmappings->{$idx} } ) {
             log_info {"Adding mapping: $idx/$type"};
             $es->indices->put_mapping(
                 index => $idx,
                 type  => $type,
-                body  => { $type => $mappings{$idx}{$type} },
+                body  => { $type => $rmappings->{$idx}{$type} },
             );
         }
     }
 
     # create aliases
 
-    my %aliases = ( 'cpan' => $cpan_index );
-    for my $alias ( sort keys %aliases ) {
-        log_info {"Creating alias: '$alias' -> '$aliases{$alias}'"};
+    my $raliases = $self->_build_aliases;
+    for my $alias ( sort keys %$raliases ) {
+        log_info {
+            "Creating alias: '$alias' -> '" . $raliases->{$alias} . "'"
+        };
         $es->indices->put_alias(
-            index => $aliases{$alias},
+            index => $raliases->{$alias},
             name  => $alias,
         );
     }
 
     $self->check_health(1);
-    $imappingok = $self->verify_mapping( \%mappings, \%aliases );
+    $is_mapping_ok = $self->mappings_valid( $rmappings, $raliases );
 
     # done
     log_info {"Done."};
 
-    return $imappingok;
+    return $is_mapping_ok;
 }
 
-sub verify_mapping {
-    my ( $self, $rmappings, $raliases ) = @_;
-    my $ihealth = 0;
+sub aliases_valid {
+    my ( $self, $raliases ) = @_;
+    my $ivalid = 0;
 
-    if ( defined $rmappings && ref $rmappings eq 'HASH' ) {
-        my $rhealth = undef;
+    if ( defined $raliases && ref $raliases eq 'HASH' ) {
+        my $ralias = undef;
 
-        $ihealth = 1;
+        $ivalid = 1;
 
-        for my $idx ( sort keys %$rmappings ) {
-            $rhealth = $self->indices_info->{$idx};
-            if ( defined $rhealth ) {
-                if ( $rhealth->{'health'} eq 'red' ) {
-                    log_error {
-                        "Broken index: $idx (state '"
-                            . $rhealth->{'health'} . "')"
+        for my $name ( sort keys %$raliases ) {
+            $ralias = $self->aliases_info->{$name};
+            if ( defined $ralias ) {
+                if ( $ralias->{'index'} eq $raliases->{$name} ) {
+                    log_info {
+                        "Correct alias: $name (index '"
+                            . $ralias->{'index'} . "')"
                     };
-                    $ihealth = 0;
                 }
                 else {
-                    log_info {
-                        "Healthy index: $idx (state '"
-                            . $rhealth->{'health'} . "')"
+                    log_error {
+                        "Broken alias: $name (index '"
+                            . $ralias->{'index'} . "')"
                     };
+                    $ivalid = 0;
                 }
             }
             else {
-                log_error {"Missing index: $idx"};
-                $ihealth = 0;
+                log_error {"Missing alias: $name"};
+                $ivalid = 0;
             }
         }
     }
+    else {
+        $ivalid = 0 if ( scalar( keys %{ $self->aliases_info } ) == 0 );
+    }
 
-    if ( defined $raliases && ref $raliases eq 'HASH' ) {
-        my $ralias = undef;
-        for my $name ( sort keys %$raliases ) {
-            $ralias = $self->aliases_info->{$name};
-            if ( defined $ralias ) {
-                if ( $ralias->{'index'} eq $raliases->{$name} ) {
+    return $ivalid;
+}
+
+sub _compare_mapping {
+    my ( $self, $sname, $rdeploy, $rmodel ) = @_;
+    my $imatch = 0;
+
+    if ( defined $rdeploy && defined $rmodel ) {
+        my $json_parser = Cpanel::JSON::XS->new->allow_nonref;
+        my ( $deploy_type, $deploy_value );
+        my ( $model_type,  $model_value );
+
+        $imatch = 1;
+
+        if ( ref $rdeploy eq 'HASH' ) {
+            my $sfield = undef;
+
+            foreach $sfield ( sort keys %$rdeploy ) {
+                if (   defined $rdeploy->{$sfield}
+                    && defined $rmodel->{$sfield} )
+                {
+                    $deploy_type  = ref( $rdeploy->{$sfield} );
+                    $model_type   = ref( $rmodel->{$sfield} );
+                    $deploy_value = $rdeploy->{$sfield};
+                    $model_value  = $rmodel->{$sfield};
+
+                    if ( $deploy_type eq 'JSON::PP::Boolean' ) {
+                        $deploy_type = '';
+                        $deploy_value
+                            = $json_parser->encode( $rdeploy->{$sfield} );
+                    }
+
+                    if ( $model_type eq 'JSON::PP::Boolean' ) {
+                        $model_type = '';
+                        $model_value
+                            = $json_parser->encode( $rmodel->{$sfield} );
+                    }
+
+                    if ( $deploy_type ne '' ) {
+                        if (   $deploy_type eq 'HASH'
+                            || $deploy_type eq 'ARRAY' )
+                        {
+                            $imatch = (
+                                $imatch && $self->_compare_mapping(
+                                    $sname . '.' . $sfield, $deploy_value,
+                                    $model_value
+                                )
+                            );
+                        }
+                        else {    # No Hash nor Array
+                            if ( ${$deploy_value} ne ${$model_value} ) {
+                                log_error {
+                                    'Mismatch field: '
+                                        . $sname . '.'
+                                        . $sfield . ' ('
+                                        . ${$deploy_value} . ' <> '
+                                        . ${$model_value} . ')'
+                                };
+                                $imatch = 0;
+                            }
+                        }
+                    }
+                    else {    # Scalar Value
+                        if ( $deploy_value ne $model_value ) {
+                            log_error {
+                                'Mismatch field: '
+                                    . $sname . '.'
+                                    . $sfield . ' ('
+                                    . $deploy_value . ' <> '
+                                    . $model_value . ')'
+                            };
+                            $imatch = 0;
+                        }
+                    }
+                }
+                else {
+                    unless ( defined $rdeploy->{$sfield} ) {
+                        log_error {
+                            'Missing field: ' . $sname . '.' . $sfield
+                        };
+                        $imatch = 0;
+
+                    }
+                    unless ( defined $rmodel->{$sfield} ) {
+                        log_error {
+                            'Missing definition: ' . $sname . '.' . $sfield
+                        };
+                        $imatch = 0;
+                    }
+                }
+            }
+        }
+        elsif ( ref $rdeploy eq 'ARRAY' ) {
+            my $iindex = undef;
+
+            foreach $iindex (@$rdeploy) {
+                if (   defined $rdeploy->[$iindex]
+                    && defined $rmodel->[$iindex] )
+                {
+                    $deploy_type  = ref( $rdeploy->[$iindex] );
+                    $model_type   = ref( $rmodel->[$iindex] );
+                    $deploy_value = $rdeploy->[$iindex];
+                    $model_value  = $rmodel->[$iindex];
+
+                    if ( $deploy_type eq 'JSON::PP::Boolean' ) {
+                        $deploy_type = '';
+                        $deploy_value
+                            = $json_parser->encode( $rdeploy->[$iindex] );
+                    }
+
+                    if ( $model_type eq 'JSON::PP::Boolean' ) {
+                        $model_type = '';
+                        $model_value
+                            = $json_parser->encode( $rmodel->[$iindex] );
+                    }
+
+                    if ( $deploy_type eq '' ) {    # Reference Value
+                        if (   $deploy_type eq 'HASH'
+                            || $deploy_type eq 'ARRAY' )
+                        {
+                            $imatch = (
+                                $imatch && $self->_compare_mapping(
+                                    $sname . '[' . $iindex . ']',
+                                    $deploy_value,
+                                    $model_value
+                                )
+                            );
+                        }
+                        else {    # No Hash nor Array
+                            if ( ${$deploy_value} ne ${$model_value} ) {
+                                log_error {
+                                    'Mismatch field: '
+                                        . $sname . '['
+                                        . $iindex . '] ('
+                                        . ${$deploy_value} . ' <> '
+                                        . ${$model_value} . ')'
+                                };
+                                $imatch = 0;
+                            }
+                        }
+                    }
+                    else {    # Scalar Value
+                        if ( $deploy_value ne $model_value ) {
+                            log_error {
+                                'Mismatch field: '
+                                    . $sname . '['
+                                    . $iindex . '] ('
+                                    . $deploy_value . ' <> '
+                                    . $model_value . ')'
+                            };
+                            $imatch = 0;
+                        }
+                    }
+                }
+                else {    # Missing Field
+                    unless ( defined $rdeploy->[$iindex] ) {
+                        log_error {
+                            'Missing field: ' . $sname . '[' . $iindex . ']'
+                        };
+                        $imatch = 0;
+
+                    }
+                    unless ( defined $rmodel->[$iindex] ) {
+                        log_error {
+                            'Missing definition: ' . $sname . '[' . $iindex
+                                . ']'
+                        };
+                        $imatch = 0;
+                    }
+                }
+            }
+        }
+    }
+    else {    # Missing Field
+        unless ( defined $rdeploy ) {
+            log_error { 'Missing field: ' . $sname };
+            $imatch = 0;
+        }
+        unless ( defined $rmodel ) {
+            log_error { 'Missing definition: ' . $sname };
+            $imatch = 0;
+        }
+    }
+
+    if ( $self->{'logger'}->is_debug ) {
+        if ($imatch) {
+            log_debug {"field '$sname': ok"};
+        }
+        else {
+            log_debug {"field '$sname': failed!"};
+        }
+    }
+
+    return $imatch;
+}
+
+sub mappings_valid {
+    my ( $self, $rmappings, $raliases ) = @_;
+    my $ivalid = 0;
+
+    if ( defined $rmappings && ref $rmappings eq 'HASH' ) {
+        my $rindices = $self->es->indices->get_mapping();
+        my $iindexok = 0;
+
+        $ivalid = 1;
+
+        for my $idx ( sort keys %$rmappings ) {
+            if (   defined $rindices->{$idx}
+                && defined $rindices->{$idx}->{'mappings'} )
+            {
+                log_info {
+                    "Verifying index: $idx"
+                };
+
+                $iindexok
+                    = $self->_compare_mapping( $idx,
+                    $rindices->{$idx}->{'mappings'},
+                    $rmappings->{$idx} );
+
+                if ($iindexok) {
                     log_info {
-                        "Correct alias: $name (index '"
-                            . $ralias->{'index'} . "')"
+                        "Correct index: $idx (mapping deployed)"
                     };
                 }
                 else {
                     log_error {
-                        "Broken alias: $name (index '"
-                            . $ralias->{'index'} . "')"
+                        "Broken index: $idx (mapping does not match definition)"
                     };
-                    $ihealth = 0;
+                    $ivalid = 0;
                 }
+
+                $ivalid = ( $ivalid && $iindexok );
             }
             else {
-                log_error {"Missing alias: $name"};
-                $ihealth = 0;
+                log_error {"Missing index: $idx"};
+                $ivalid = 0;
             }
         }
     }
+    if ($ivalid) {
+        log_info {"Verification indices: ok"};
+    }
     else {
-        $ihealth = 0 if ( scalar( keys %{ $self->aliases_info } ) == 0 );
+        log_info {"Verification indices: failed"};
     }
 
-    return $ihealth;
+    $ivalid = ( $ivalid && $self->aliases_valid($raliases) );
+
+    if ($ivalid) {
+        log_info {"Verification aliases: ok"};
+    }
+    else {
+        log_info {"Verification aliases: failed"};
+    }
+
+    return $ivalid;
 }
 
 __PACKAGE__->meta->make_immutable;
@@ -574,6 +851,7 @@ MetaCPAN::Script::Mapping - Script to set the index and mapping the types
 
  # bin/metacpan mapping --show_cluster_info   # show basic info about the cluster, indices and aliases
  # bin/metacpan mapping --delete
+ # bin/metacpan mapping --verify              # compare deployed indices and aliases with project definitions
  # bin/metacpan mapping --list_types
  # bin/metacpan mapping --delete_index xxx
  # bin/metacpan mapping --create_index xxx --reindex
@@ -611,18 +889,29 @@ See L<Method C<MetaCPAN::Role::Script::check_health()>>
 
 This option makes the Script delete all indices configured in the project and re-create them emtpy.
 It verifies the index integrity of the indices and aliases calling the methods
-C<MetaCPAN::Role::Script::check_health()> and C<verify_mapping()>.
-If the C<verify_mapping()> Method fails it exits the Script
-with B<Exit Code> C< 1 >.
+C<MetaCPAN::Role::Script::check_health()> and C<mappings_valid()>.
+If the C<mappings_valid()> Method fails it will report an error.
 
     bin/metacpan mapping --delete
 
+B<Exit Code:> If the mapping deployment fails it exits the Script with B<Exit Code> C< 1 >.
+
 See L<Method C<deploy_mapping()>>
 
-See L<Method C<verify_mapping()>>
+See L<Method C<mappings_valid()>>
 
 See L<Method C<MetaCPAN::Role::Script::check_health()>>
 
+=item Option C<--verify>
+
+This option will request the index mappings from the I<ElasticSearch> Cluster and
+compare them indepth with the Project Definitions.
+
+    bin/metacpan mapping --verify
+
+B<Exit Code:> If the deployed mappings do not match the defined mappings
+it exits the Script with B<Exit Code> C< 1 >.
+
 =back
 
 =head1 METHODS
@@ -635,7 +924,7 @@ This Package provides the following methods
 
 Deletes and re-creates the indices and aliases defined in the Project.
 The user will be requested for manual confirmation on the command line before the elemination.
-The integrity of the indices and aliases will be checked with the C<verify_mapping()> Method.
+The integrity of the indices and aliases will be checked with the C<mappings_valid()> Method.
 On successful creation it returns C< 1 >, otherwise it returns C< 0 >.
 
 B<Returns:> It returns C< 1 > when the indices and aliases are created and verified as correct.
@@ -646,15 +935,19 @@ or there is any issue in any I<ElasticSearch> Request run by the Script.
 
 See L<Option C<--delete>>
 
-See L<Method C<verify_mapping()>>
+See L<Method C<mappings_valid()>>
 
 See L<Method C<MetaCPAN::Role::Script::check_health()>>
 
-=item C<verify_mapping( \%indices, \%aliases )>
+=item C<mappings_valid( \%indices, \%aliases )>
 
-Checks the defined indices and aliases against the actually in the I<ElasticSearch> Cluster
-existing indices and aliases which must have been requested with
-the C<MetaCPAN::Role::Script::check_health()> Method.
+This method uses the
+L<C<Search::Elasticsearch::Client::2_0::Direct::get_mapping()>|https://metacpan.org/pod/Search::Elasticsearch::Client::2_0::Direct#get_mapping()>
+method to request the complete index mappings structure from the I<ElasticSearch> Cluster.
+It also uses the alias information gathered by the C<MetaCPAN::Role::Script::check_health()> method.
+Then it performs an in-depth structure match against the Project Definitions.
+Missing indices or any structure mismatch will be count as error.
+Errors will be reported in the activity log.
 
 B<Parameters:>
 
@@ -662,15 +955,12 @@ C<\%indices> - Reference to a hash that defines the indices required for the Pro
 
 C<\%aliases> - Reference to a hash that defines the aliases required for the Project.
 
-B<Returns:> It returns C< 1 > when the indices and aliases are created and verified as correct.
+B<Returns:> It returns C< 1 > when the indices and aliases are created and match the defined structure.
 Otherwise it returns C< 0 >.
 
-B<Exceptions:> It can throw exceptions when the connection to I<ElasticSearch> fails
-or there is any issue in any I<ElasticSearch> Request run by the Script.
-
 See L<Option C<--delete>>
 
-See L<Method C<verify_mapping()>>
+See L<Method C<mappings_valid()>>
 
 See L<Method C<MetaCPAN::Role::Script::check_health()>>
 
diff --git a/t/00_setup.t b/t/00_setup.t
index bfe1a4552..e9ab5f039 100644
--- a/t/00_setup.t
+++ b/t/00_setup.t
@@ -37,6 +37,9 @@ ok( $tmp_dir->stat, "$tmp_dir exists for testing" );
 my $server = MetaCPAN::TestServer->new;
 $server->setup;
 
+# Run the Mappings Tests
+$server->test_mappings;
+
 my $config = get_config();
 $config->{es} = $server->es_client;
 
diff --git a/t/lib/MetaCPAN/TestServer.pm b/t/lib/MetaCPAN/TestServer.pm
index df066e694..9c83eb179 100644
--- a/t/lib/MetaCPAN/TestServer.pm
+++ b/t/lib/MetaCPAN/TestServer.pm
@@ -10,6 +10,7 @@ use MetaCPAN::Script::Favorite       ();
 use MetaCPAN::Script::First          ();
 use MetaCPAN::Script::Latest         ();
 use MetaCPAN::Script::Mapping        ();
+use MetaCPAN::Script::Mapping::Cover ();
 use MetaCPAN::Script::Mirrors        ();
 use MetaCPAN::Script::Package        ();
 use MetaCPAN::Script::Permission     ();
@@ -62,6 +63,8 @@ sub setup {
     my $self = shift;
 
     $self->es_client;
+
+    # Deploy project mappings
     $self->put_mappings;
 }
 
@@ -161,7 +164,7 @@ sub wait_for_es {
     $self->es_client->indices->refresh;
 }
 
-sub verify_mappings {
+sub check_mappings {
     my $self           = $_[0];
     my %hshtestindices = (
         'cover'       => 'yellow',
@@ -193,7 +196,7 @@ sub verify_mappings {
         ok( defined $hshtestindices{$_}, "indice '$_' is configured" )
             foreach ( keys %{ $mapping->indices_info } );
     };
-    subtest 'verify indix health' => sub {
+    subtest 'verify index health' => sub {
         foreach ( keys %hshtestindices ) {
             ok( defined $mapping->indices_info->{$_},
                 "indice '$_' was created" );
@@ -219,7 +222,7 @@ sub put_mappings {
     local @ARGV = qw(mapping --delete);
     ok( MetaCPAN::Script::Mapping->new_with_options( $self->_config )->run,
         'put mapping' );
-    $self->verify_mappings;
+    $self->check_mappings;
     $self->wait_for_es();
 }
 
@@ -227,9 +230,8 @@ sub index_releases {
     my $self = shift;
     my %args = @_;
 
-    local @ARGV = (
-        'release', $ENV{MC_RELEASE} ? $ENV{MC_RELEASE} : $self->_cpan_dir
-    );
+    local @ARGV = ( 'release',
+        $ENV{MC_RELEASE} ? $ENV{MC_RELEASE} : $self->_cpan_dir );
     ok(
         MetaCPAN::Script::Release->new_with_options( %{ $self->_config },
             %args )->run,
@@ -355,5 +357,116 @@ sub prepare_user_test_data {
     );
 }
 
+sub test_mappings {
+    my $self = $_[0];
+
+    $self->test_index_missing;
+    $self->test_field_mismatch;
+}
+
+sub test_index_missing {
+    my $self = $_[0];
+
+    subtest 'missing index' => sub {
+        my $scoverindexjson = MetaCPAN::Script::Mapping::Cover::mapping;
+
+        subtest 'delete cover index' => sub {
+            local @ARGV = qw(mapping --delete_index cover);
+            my $mapping
+                = MetaCPAN::Script::Mapping->new_with_options(
+                $self->_config );
+
+            ok( $mapping->run, "deletion 'cover' succeeds" );
+            is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+        };
+        subtest 'mapping verification fails' => sub {
+            local @ARGV = qw(mapping --verify);
+            my $mapping
+                = MetaCPAN::Script::Mapping->new_with_options(
+                $self->_config );
+
+            is( $mapping->run, 0, "verification execution fails" );
+            is( $mapping->exit_code, 1,
+                "Exit Code '1' - Verification Error" );
+        };
+        subtest 're-create cover index' => sub {
+            local @ARGV = (
+                'mapping', '--create_index',
+                'cover',   '--patch_mapping',
+                qq({ "cover": $scoverindexjson })
+            );
+            my $mapping
+                = MetaCPAN::Script::Mapping->new_with_options(
+                $self->_config );
+
+            ok( $mapping->run, "creation 'cover' succeeds" );
+            is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+        };
+    };
+}
+
+sub test_field_mismatch {
+    my $self = $_[0];
+
+    subtest 'field mismatch' => sub {
+        my $sfieldjson = q({
+   "properties" : {
+      "version" : {
+         "index" : "not_analyzed",
+         "ignore_above" : 2048,
+         "type" : "string"
+      }
+   }
+});
+        my $sfieldchangejson = q({
+   "properties" : {
+      "version" : {
+         "type" : "string",
+         "index" : "not_analyzed",
+         "ignore_above" : 1024
+      }
+   }
+});
+
+        subtest 'mapping change field' => sub {
+            local @ARGV = (
+                'mapping', '--update_index',
+                'cover',   '--patch_mapping',
+                qq({ "cover": $sfieldchangejson })
+            );
+            my $mapping
+                = MetaCPAN::Script::Mapping->new_with_options(
+                $self->_config );
+
+            ok( $mapping->run, "change 'cover' succeeds" );
+
+            is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+        };
+        subtest 'field verification fails' => sub {
+            local @ARGV = qw(mapping --verify);
+            my $mapping
+                = MetaCPAN::Script::Mapping->new_with_options(
+                $self->_config );
+
+            is( $mapping->run, 0, "verification fails" );
+            is( $mapping->exit_code, 1,
+                "Exit Code '1' - Verification Error" );
+        };
+        subtest 'mapping re-establish field' => sub {
+            local @ARGV = (
+                'mapping', '--update_index',
+                'cover',   '--patch_mapping',
+                qq({ "cover": $sfieldjson })
+            );
+            my $mapping
+                = MetaCPAN::Script::Mapping->new_with_options(
+                $self->_config );
+
+            ok( $mapping->run, "re-establish 'cover' succeeds" );
+            is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+        };
+    };
+}
+
 __PACKAGE__->meta->make_immutable;
 1;
diff --git a/t/script/mapping.t b/t/script/mapping.t
new file mode 100644
index 000000000..135b60521
--- /dev/null
+++ b/t/script/mapping.t
@@ -0,0 +1,20 @@
+use strict;
+use warnings;
+use lib 't/lib';
+
+use Test::More;
+
+use MetaCPAN::Script::Runner qw(build_config);
+use MetaCPAN::Script::Mapping;
+
+my $config = MetaCPAN::Script::Runner::build_config;
+
+subtest 'mapping verification succeeds' => sub {
+    local @ARGV = ( 'mapping', '--verify' );
+    my $mapping = MetaCPAN::Script::Mapping->new_with_options($config);
+
+    ok( $mapping->run, "verification succeeds" );
+    is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+};
+
+done_testing();