diff --git a/lib/MetaCPAN/Role/Script.pm b/lib/MetaCPAN/Role/Script.pm
index 102f80174..c8532597f 100644
--- a/lib/MetaCPAN/Role/Script.pm
+++ b/lib/MetaCPAN/Role/Script.pm
@@ -364,17 +364,32 @@ sub await {
 
 sub are_you_sure {
     my ( $self, $msg ) = @_;
+    my $iconfirmed = 0;
 
     if (is_interactive) {
-        print colored( ['bold red'], "*** Warning ***: $msg" ), "\n";
-        my $answer = prompt
-            'Are you sure you want to do this (type "YES" to confirm) ? ';
+        my $answer
+            = prompt colored( ['bold red'], "*** Warning ***: $msg" ) . "\n"
+            . 'Are you sure you want to do this (type "YES" to confirm) ? ';
         if ( $answer ne 'YES' ) {
-            print "bye.\n";
-            exit 0;
+            log_error {"Confirmation incorrect: '$answer'"};
+            print "Operation will be interruped!\n";
+
+            #Set System Error: 125 - ECANCELED - Operation canceled
+            $self->exit_code(125);
+            $self->handle_error( 'Operation canceled on User Request', 1 );
+        }
+        else {
+            log_info {'Operation confirmed.'};
+            print "alright then...\n";
+            $iconfirmed = 1;
         }
-        print "alright then...\n";
     }
+    else {
+        print colored( ['bold yellow'], "*** Warning ***: $msg" ) . "\n";
+        $iconfirmed = 1;
+    }
+
+    return $iconfirmed;
 }
 
 1;
@@ -405,6 +420,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
@@ -421,11 +439,16 @@ This method uses the
 L<C<Search::Elasticsearch::Client::2_0::Direct::ping()>|https://metacpan.org/pod/Search::Elasticsearch::Client::2_0::Direct#ping()>
 method to verify the service availabilty and wait for C<arg_await_timeout> seconds.
 When the service does not become available within C<arg_await_timeout> seconds it re-throws the
-Exception from the C<Search::Elasticsearch::Client> and sets C< $! > to C< 112 >.
+Exception from the C<Search::Elasticsearch::Client> and sets B<Exit Code> 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,10 +466,20 @@ 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 >"
 
+B<Exceptions:> When the operator input does not match "I< YES >" it will exit the Script
+with Exit Code [125] (C<125 - ECANCELED - Operation canceled>).
+
 =item C<handle_error( error_message[, die_always ] )>
 
 Logs the string C<error_message> with the log function as fatal error.
diff --git a/lib/MetaCPAN/Script/Mapping.pm b/lib/MetaCPAN/Script/Mapping.pm
index 71c4f41fd..249011aac 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,23 @@ has arg_deploy_mapping => (
     documentation => 'delete index if it exists already',
 );
 
+has arg_delete_all => (
+    init_arg      => 'all',
+    is            => 'ro',
+    isa           => Bool,
+    default       => 0,
+    documentation =>
+        'delete ALL existing indices (only effective in combination with "--delete")',
+);
+
+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',
@@ -132,19 +156,37 @@ sub run {
     my $self = shift;
 
     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->delete_index if $self->arg_delete_index;
         $self->copy_type    if $self->copy_to_index;
         $self->empty_type   if $self->delete_from_type;
         $self->list_types   if $self->arg_list_types;
 
         if ( $self->arg_deploy_mapping ) {
+            if ( $self->arg_delete_all ) {
+                $self->check_health;
+                $self->delete_all;
+            }
             unless ( $self->deploy_mapping ) {
                 $self->print_error("Indices Re-creation has failed!");
                 $self->exit_code(1);
             }
         }
 
+        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 +194,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 +203,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 );
     }
 }
 
@@ -180,6 +228,39 @@ sub delete_index {
     $self->_delete_index($name);
 }
 
+sub delete_all {
+    my $self                = $_[0];
+    my $runtime_environment = 'production';
+    my $is_development      = 0;
+
+    $runtime_environment = $ENV{'PLACK_ENV'}
+        if ( defined $ENV{'PLACK_ENV'} );
+    $runtime_environment = $ENV{'MOJO_MODE'}
+        if ( defined $ENV{'MOJO_MODE'} );
+
+    $is_development = 1
+        if ( $runtime_environment eq 'development'
+        || $runtime_environment eq 'testing' );
+
+    if ($is_development) {
+        my $name = undef;
+
+        $self->are_you_sure("ALL Indices will be deleted !!!");
+
+        foreach $name ( keys %{ $self->indices_info } ) {
+            $self->_delete_index($name);
+        }
+    }
+    else {
+        #Set System Error: 1 - EPERM - Operation not permitted
+        $self->exit_code(1);
+        $self->print_error("Operation not permitted!");
+        $self->handle_error(
+            "Operation not permitted in environment: $runtime_environment",
+            1 );
+    }
+}
+
 sub _delete_index {
     my ( $self, $name ) = @_;
 
@@ -208,7 +289,9 @@ 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 => $self->index->name,
+            index => $name,
             type  => $type,
             body  => { $type => $mapping->{$type} },
         );
@@ -404,16 +487,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 +526,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 $imappingok = 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,35 +552,37 @@ 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 );
+    $imappingok = $self->mappings_valid( $rmappings, $raliases );
 
     # done
     log_info {"Done."};
@@ -494,69 +590,298 @@ sub deploy_mapping {
     return $imappingok;
 }
 
-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
+                            unless ( ${$deploy_value} eq ${$model_value} ) {
+                                log_error {
+                                    'Mismatch field: '
+                                        . $sname . '.'
+                                        . $sfield . ' ('
+                                        . ${$deploy_value} . ' <> '
+                                        . ${$model_value} . ')'
+                                };
+                                $imatch = 0;
+                            }
+                        }
+                    }
+                    else {    # Scalar Value
+                        unless ( $deploy_value eq $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
+                            unless ( ${$deploy_value} eq ${$model_value} ) {
+                                log_error {
+                                    'Mismatch field: '
+                                        . $sname . '['
+                                        . $iindex . '] ('
+                                        . ${$deploy_value} . ' <> '
+                                        . ${$model_value} . ')'
+                                };
+                                $imatch = 0;
+                            }
+                        }
+                    }
+                    else {    # Scalar Value
+                        unless ( $deploy_value eq $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 +899,8 @@ 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 --delete --all        # deletes ALL indices in the cluster
+ # 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 +938,47 @@ 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<--all>
+
+This option is only effective in combination with Option C<--delete>.
+It uses the information gathered by C<MetaCPAN::Role::Script::check_health()> to delete
+B<ALL> indices in the I<ElasticSearch> Cluster.
+This option is usefull to reconstruct a broken I<ElasticSearch> Cluster
+
+    bin/metacpan mapping --delete --all
+
+B<Exceptions:> It will throw an exceptions when not performed in an development or
+testing environment.
+
+See L<Option C<--delete>>
+
+See L<Method C<deploy_mapping()>>
+
+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 +991,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 +1002,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 +1022,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<check_mapping()>>
 
 See L<Method C<MetaCPAN::Role::Script::check_health()>>
 
diff --git a/lib/MetaCPAN/Script/Runner.pm b/lib/MetaCPAN/Script/Runner.pm
index 9aa2e0705..4a1cb3f0c 100644
--- a/lib/MetaCPAN/Script/Runner.pm
+++ b/lib/MetaCPAN/Script/Runner.pm
@@ -63,7 +63,7 @@ sub run {
 
         # Display Exception Message in red
         print colored( ['bold red'],
-            "*** EXECPTION [ $EXIT_CODE ] ***: " . $ex->{'message'} ),
+            "*** EXCEPTION [ $EXIT_CODE ] ***: " . $ex->{'message'} ),
             "\n";
     };
 
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..ac5810b2d 100644
--- a/t/lib/MetaCPAN/TestServer.pm
+++ b/t/lib/MetaCPAN/TestServer.pm
@@ -10,10 +10,12 @@ 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     ();
 use MetaCPAN::Script::Release        ();
+use MetaCPAN::Script::Runner         ();
 use MetaCPAN::Server                 ();
 use MetaCPAN::TestHelpers qw( fakecpan_dir );
 use MetaCPAN::Types::TypeTiny qw( Path HashRef Str );
@@ -62,6 +64,11 @@ sub setup {
     my $self = shift;
 
     $self->es_client;
+
+    # Run the Delete Index Tests before mapping deployment
+    $self->test_delete_mappings;
+
+    # Deploy project mappings
     $self->put_mappings;
 }
 
@@ -161,7 +168,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 +200,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 +226,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 +234,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 +361,211 @@ 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" : {
+              "ignore_above" : 2048,
+              "index" : "not_analyzed",
+              "type" : "string"
+            }
+	  }
+	});
+        my $sfieldchangejson = q({
+          "properties" : {
+            "version" : {
+              "ignore_above" : 1024,
+              "index" : "not_analyzed",
+              "type" : "string"
+            }
+	  }
+	});
+
+        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" );
+        };
+    };
+}
+
+sub test_delete_mappings {
+    my $self = $_[0];
+
+    $self->test_delete_fails;
+    $self->test_delete_all;
+}
+
+sub test_delete_fails {
+    my $self = $_[0];
+
+    my $iexitcode;
+    my $irunok;
+
+    subtest 'delete all not permitted' => sub {
+
+        # mapping script - delete indices
+        {
+            local @ARGV = qw(mapping --delete --all);
+            local %ENV  = (%ENV);
+
+            delete $ENV{'PLACK_ENV'};
+            delete $ENV{'MOJO_MODE'};
+
+            $irunok    = MetaCPAN::Script::Runner::run;
+            $iexitcode = $MetaCPAN::Script::Runner::EXIT_CODE;
+        }
+
+        ok( !$irunok, "delete all fails" );
+        is( $iexitcode, 1, "Exit Code '1' - Permission Error" );
+    };
+}
+
+sub test_delete_all {
+    my $self = $_[0];
+
+    subtest 'delete all deletes unknown index' => sub {
+        subtest 'create index' => sub {
+            my $smockindexjson = q({
+              "mock_index": {
+                "properties": {
+		  "mock_field" : {
+		    "type" : "string",
+		    "index" : "not_analyzed",
+		    "ignore_above" : 2048
+                  }
+		}
+	      }
+	    });
+
+            local @ARGV = (
+                'mapping',    '--create_index',
+                'mock_index', '--patch_mapping',
+                $smockindexjson
+            );
+
+            ok( MetaCPAN::Script::Runner::run,
+                "creation 'mock_index' succeeds"
+            );
+            is( $MetaCPAN::Script::Runner::EXIT_CODE,
+                0, "Exit Code '0' - No Error" );
+        };
+        subtest 'info shows unknonwn index' => sub {
+            local @ARGV = ( 'mapping', '--show_cluster_info' );
+            my $mapping = MetaCPAN::Script::Mapping->new_with_options(
+                $self->_config );
+
+            ok( $mapping->run, "show info succeeds" );
+            is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+
+            ok( defined $mapping->indices_info, 'Index Info built' );
+            ok( defined $mapping->indices_info->{'mock_index'},
+                'Unknown Index printed' );
+        };
+        subtest 'delete all succeeds' => sub {
+            local @ARGV = qw(mapping --delete --all);
+
+            ok( MetaCPAN::Script::Runner::run, "delete all succeeds" );
+            is( $MetaCPAN::Script::Runner::EXIT_CODE,
+                0, "Exit Code '0' - No Error" );
+        };
+        subtest 'info does not show unknown index' => sub {
+            local @ARGV = ( 'mapping', '--show_cluster_info' );
+            my $mapping = MetaCPAN::Script::Mapping->new_with_options(
+                $self->_config );
+
+            ok( $mapping->run, "show info succeeds" );
+            is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+
+            ok( defined $mapping->indices_info, 'Index Info built' );
+            ok( !defined $mapping->indices_info->{'mock_index'},
+                'Unknown Index printed' );
+        };
+    };
+}
+
 __PACKAGE__->meta->make_immutable;
 1;
diff --git a/t/script/mapping.t b/t/script/mapping.t
new file mode 100644
index 000000000..0ca7dd756
--- /dev/null
+++ b/t/script/mapping.t
@@ -0,0 +1,74 @@
+use strict;
+use warnings;
+use lib 't/lib';
+
+use Test::More;
+
+use MetaCPAN::Script::Runner;
+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" );
+};
+
+subtest 'create, delete index' => sub {
+    subtest 'create index' => sub {
+        my $smockindexjson = q({
+          "mock_index": {
+	    "properties": {
+	      "mock_field": {
+		"type": "string",
+		"index": "not_analyzed",
+		"ignore_above": 2048
+              }
+	    }
+          }
+	});
+        local @ARGV = (
+            'mapping',    '--create_index',
+            'mock_index', '--patch_mapping',
+            $smockindexjson
+        );
+        my $mapping = MetaCPAN::Script::Mapping->new_with_options($config);
+
+        ok( $mapping->run, "creation 'mock_index' succeeds" );
+        is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+    };
+    subtest 'info shows new index' => sub {
+        local @ARGV = ( 'mapping', '--show_cluster_info' );
+        my $mapping = MetaCPAN::Script::Mapping->new_with_options($config);
+
+        ok( $mapping->run, "show info succeeds" );
+        is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+
+        ok( defined $mapping->indices_info, 'Index Info built' );
+        ok( defined $mapping->indices_info->{'mock_index'},
+            'Created Index printed' );
+    };
+    subtest 'delete index' => sub {
+        local @ARGV = ( 'mapping', '--delete_index', 'mock_index' );
+        my $mapping = MetaCPAN::Script::Mapping->new_with_options($config);
+
+        ok( $mapping->run, "deletion 'mock_index' succeeds" );
+        is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+    };
+    subtest 'info does not show deleted index' => sub {
+        local @ARGV = ( 'mapping', '--show_cluster_info' );
+        my $mapping = MetaCPAN::Script::Mapping->new_with_options($config);
+
+        ok( $mapping->run, "show info succeeds" );
+        is( $mapping->exit_code, 0, "Exit Code '0' - No Error" );
+
+        ok( defined $mapping->indices_info, 'Index Info printed' );
+        ok( !defined $mapping->indices_info->{'mock_index'},
+            'Deleted Index not printed' );
+    };
+};
+
+done_testing();