Merge branch '1819-override' into 'master'

Override module to specify that we're overriding

Closes #1819

See merge request gitlab-org/gitlab-ee!3876

app/models/concerns/sha_attribute.rb

@@ -3,6 +3,7 @@ module ShaAttribute
 
   module ClassMethods
     def sha_attribute(name)
+      return if ENV['STATIC_VERIFICATION']
       return unless table_exists?
 
       column = columns.find { |c| c.name == name.to_s }

doc/development/ee_features.md

@@ -87,9 +87,9 @@ still having access the class's implementation with `super`.
 
 There are a few gotchas with it:
 
-- you should always add a `raise NotImplementedError unless defined?(super)`
-  guard clause in the "overrider" method to ensure that if the method gets
-  renamed in CE, the EE override won't be silently forgotten.
+- you should always [`extend ::Gitlab::Utils::Override`] and use `override` to
+  guard the "overrider" method to ensure that if the method gets renamed in
+  CE, the EE override won't be silently forgotten.
 - when the "overrider" would add a line in the middle of the CE
   implementation, you should refactor the CE method and split it in
   smaller methods. Or create a "hook" method that is empty in CE,
@@ -134,6 +134,9 @@ There are a few gotchas with it:
   guards:
   ``` ruby
     module EE::Base
+      extend ::Gitlab::Utils::Override
+
+      override :do_something
       def do_something
         # Follow the above pattern to call super and extend it
       end
@@ -174,10 +177,11 @@ implementation:
 
 ```ruby
 module EE
-  class ApplicationController
-    def after_sign_out_path_for(resource)
-      raise NotImplementedError unless defined?(super)
+  module ApplicationController
+    extend ::Gitlab::Utils::Override
 
+    override :after_sign_out_path_for
+    def after_sign_out_path_for(resource)
       if Gitlab::Geo.secondary?
         Gitlab::Geo.primary_node.oauth_logout_url(@geo_logout_state)
       else
@@ -188,6 +192,8 @@ module EE
 end
 ```
 
+[`extend ::Gitlab::Utils::Override`]: utilities.md#override
+
 #### Use self-descriptive wrapper methods
 
 When it's not possible/logical to modify the implementation of a
@@ -208,8 +214,8 @@ end
 In EE, the implementation `ee/app/models/ee/users.rb` would be:
 
 ```ruby
+override :full_private_access?
 def full_private_access?
-  raise NotImplementedError unless defined?(super)
   super || auditor?
 end
 ```

doc/development/utilities.md

@@ -45,6 +45,51 @@ We developed a number of utilities to ease development.
     [:hello, "world", :this, :crushes, "an entire", "hash"]
     ```
 
+## [`Override`](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/lib/gitlab/utils/override.rb)
+
+* This utility could help us check if a particular method would override
+  another method or not. It has the same idea of Java's `@Override` annotation
+  or Scala's `override` keyword. However we only do this check when
+  `ENV['STATIC_VERIFICATION']` is set to avoid production runtime overhead.
+  This is useful to check:
+
+    * If we have typos in overriding methods.
+    * If we renamed the overridden methods, making original overriding methods
+      overrides nothing.
+
+    Here's a simple example:
+
+    ``` ruby
+    class Base
+      def execute
+      end
+    end
+
+    class Derived < Base
+      extend ::Gitlab::Utils::Override
+
+      override :execute # Override check happens here
+      def execute
+      end
+    end
+    ```
+
+    This also works on modules:
+
+    ``` ruby
+    module Extension
+      extend ::Gitlab::Utils::Override
+
+      override :execute # Modules do not check this immediately
+      def execute
+      end
+    end
+
+    class Derived < Base
+      prepend Extension # Override check happens here, not in the module
+    end
+    ```
+
 ## [`StrongMemoize`](https://gitlab.com/gitlab-org/gitlab-ce/blob/master/lib/gitlab/utils/strong_memoize.rb)
 
 * Memoize the value even if it is `nil` or `false`.

ee/app/controllers/ee/admin/applications_controller.rb

 module EE
   module Admin
     module ApplicationsController
+      extend ::Gitlab::Utils::Override
+
       protected
 
+      override :redirect_to_admin_page
       def redirect_to_admin_page
-        raise NotImplementedError unless defined?(super)
-
         log_audit_event
 
         super

ee/app/controllers/ee/admin/logs_controller.rb

 module EE::Admin::LogsController
   include ::Gitlab::Utils::StrongMemoize
+  extend ::Gitlab::Utils::Override
 
+  override :loggers
   def loggers
-    raise NotImplementedError unless defined?(super)
-
     strong_memoize(:loggers) do
       super + [
         Gitlab::GeoLogger

ee/app/controllers/ee/confirmations_controller.rb

 module EE
   module ConfirmationsController
     include EE::Audit::Changes
+    extend ::Gitlab::Utils::Override
 
     protected
 
+    override :after_sign_in
     def after_sign_in(resource)
-      raise NotImplementedError unless defined?(super)
-
       audit_changes(:email, as: 'email address', model: resource)
 
       super(resource)

ee/app/controllers/ee/projects/git_http_controller.rb

 module EE
   module Projects
     module GitHttpController
-      def render_ok
-        raise NotImplementedError.new unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :render_ok
+      def render_ok
         set_workhorse_internal_api_content_type
         render json: ::Gitlab::Workhorse.git_http_ok(repository, wiki?, user, action_name, show_all_refs: geo_request?)
       end
@@ -18,17 +19,15 @@ module EE
         authentication_result.geo?(project)
       end
 
+      override :access_actor
       def access_actor
-        raise NotImplementedError.new unless defined?(super)
-
         return :geo if geo?
 
         super
       end
 
+      override :authenticate_user
       def authenticate_user
-        raise NotImplementedError.new unless defined?(super)
-
         return super unless geo_request?
 
         payload = ::Gitlab::Geo::JwtRequestDecoder.new(request.headers['Authorization']).decode

ee/app/controllers/ee/projects/lfs_api_controller.rb

 module EE
   module Projects
     module LfsApiController
-      def lfs_read_only_message
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :lfs_read_only_message
+      def lfs_read_only_message
         return super unless ::Gitlab::Geo.secondary_with_primary?
 
         (_('You cannot write to a read-only secondary GitLab Geo instance. Please use %{link_to_primary_node} instead.') % { link_to_primary_node: geo_primary_default_url_to_repo(project) }).html_safe

ee/app/controllers/ee/sessions_controller.rb

 module EE
   module SessionsController
     extend ActiveSupport::Concern
+    extend ::Gitlab::Utils::Override
 
     prepended do
       before_action :gitlab_geo_login, only: [:new]
@@ -36,9 +37,8 @@ module EE
       super
     end
 
+    override :redirect_allowed_to?
     def redirect_allowed_to?(uri)
-      raise NotImplementedError unless defined?(super)
-
       # Redirect is not only allowed to current host, but also to other Geo
       # nodes. relative_url_root *must* be ignored here as we don't know what
       # is root and what is path

ee/app/helpers/ee/application_settings_helper.rb

 module EE
   module ApplicationSettingsHelper
-    def visible_attributes
-      raise NotImplementedError unless defined?(super)
+    extend ::Gitlab::Utils::Override
 
+    override :visible_attributes
+    def visible_attributes
       super + [
         :check_namespace_plan,
         :elasticsearch_aws,

ee/app/models/concerns/ee/protected_ref_access.rb

@@ -8,6 +8,7 @@
 module EE
   module ProtectedRefAccess
     extend ActiveSupport::Concern
+    extend ::Gitlab::Utils::Override
 
     included do
       belongs_to :user
@@ -40,12 +41,12 @@ module EE
     end
 
     # Is this a role-based access level?
+    override :role?
     def role?
-      raise NotImplementedError unless defined?(super)
-
       type == :role
     end
 
+    override :humanize
     def humanize
       return self.user.name if self.user.present?
       return self.group.name if self.group.present?
@@ -53,6 +54,7 @@ module EE
       super
     end
 
+    override :check_access
     def check_access(user)
       return true if user.admin?
       return user.id == self.user_id if self.user.present?

ee/app/models/ee/namespace.rb

@@ -5,6 +5,7 @@ module EE
   # and be prepended in the `Namespace` model
   module Namespace
     extend ActiveSupport::Concern
+    extend ::Gitlab::Utils::Override
     include ::Gitlab::Utils::StrongMemoize
 
     FREE_PLAN = 'free'.freeze
@@ -44,9 +45,8 @@ module EE
       end
     end
 
+    override :move_dir
     def move_dir
-      raise NotImplementedError unless defined?(super)
-
       succeeded = super
 
       if succeeded

ee/app/models/ee/project.rb

@@ -5,6 +5,7 @@ module EE
   # and be prepended in the `Project` model
   module Project
     extend ActiveSupport::Concern
+    extend ::Gitlab::Utils::Override
     include ::Gitlab::Utils::StrongMemoize
 
     prepended do
@@ -415,9 +416,8 @@ module EE
     end
     alias_method :merge_requests_ff_only_enabled?, :merge_requests_ff_only_enabled
 
+    override :rename_repo
     def rename_repo
-      raise NotImplementedError unless defined?(super)
-
       super
 
       path_was = previous_changes['path'].first

ee/app/models/ee/project_team.rb

 module EE
   module ProjectTeam
     extend ActiveSupport::Concern
+    extend ::Gitlab::Utils::Override
 
+    override :add_users
     def add_users(users, access_level, current_user: nil, expires_at: nil)
-      raise NotImplementedError unless defined?(super)
       return false if group_member_lock
 
       super
     end
 
+    override :add_user
     def add_user(user, access_level, current_user: nil, expires_at: nil)
-      raise NotImplementedError unless defined?(super)
       return false if group_member_lock
 
       super

ee/app/services/ee/base_count_service.rb

 module EE
   module BaseCountService
+    extend ::Gitlab::Utils::Override
+
     # geo secondary cache should expire quicker than primary, otherwise various counts
     # could be incorrect for 2 weeks.
+    override :cache_options
     def cache_options
-      raise NotImplementedError.new unless defined?(super)
-
       value = super
       value[:expires_in] = 20.minutes if ::Gitlab::Geo.secondary?
       value

ee/app/services/ee/boards/create_service.rb

 module EE
   module Boards
     module CreateService
-      def can_create_board?
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :can_create_board?
+      def can_create_board?
         parent.feature_available?(:multiple_issue_boards) || super
       end
     end

ee/app/services/ee/boards/list_service.rb

 module EE
   module Boards
     module ListService
-      def execute
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :execute
+      def execute
         if parent.multiple_issue_boards_available?(current_user)
           super
         else

ee/app/services/ee/groups/create_service.rb

 module EE
   module Groups
     module CreateService
-      def execute
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :execute
+      def execute
         super.tap { |group| log_audit_event if group&.persisted? }
       end
 

ee/app/services/ee/groups/destroy_service.rb

 module EE
   module Groups
     module DestroyService
-      def execute
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :execute
+      def execute
         super.tap { |group| log_audit_event unless group&.persisted? }
       end
 

ee/app/services/ee/groups/update_service.rb

 module EE
   module Groups
     module UpdateService
-      def execute
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :execute
+      def execute
         super.tap { |success| log_audit_event if success }
       end
 

ee/app/services/ee/merge_requests/merge_service.rb

 module EE
   module MergeRequests
     module MergeService
-      def error_check!
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :error_check!
+      def error_check!
         check_size_limit
 
         super

ee/app/services/ee/projects/create_service.rb

 module EE
   module Projects
     module CreateService
-      def execute
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :execute
+      def execute
         limit = params.delete(:repository_size_limit)
         mirror = params.delete(:mirror)
         mirror_user_id = params.delete(:mirror_user_id)
@@ -34,9 +35,8 @@ module EE
         ::Geo::RepositoryCreatedEventStore.new(project).create
       end
 
+      override :after_create_actions
       def after_create_actions
-        raise NotImplementedError unless defined?(super)
-
         super
 
         create_predefined_push_rule

ee/app/services/ee/projects/destroy_service.rb

 module EE
   module Projects
     module DestroyService
-      def execute
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :execute
+      def execute
         succeeded = super
 
         if succeeded

ee/app/services/ee/projects/group_links/create_service.rb

@@ -2,9 +2,10 @@ module EE
   module Projects
     module GroupLinks
       module CreateService
-        def execute(group)
-          raise NotImplementedError unless defined?(super)
+        extend ::Gitlab::Utils::Override
 
+        override :execute
+        def execute(group)
           super.tap { |link| log_audit_event(link) if link && link&.persisted? }
         end
 

ee/app/services/ee/projects/group_links/destroy_service.rb

@@ -2,9 +2,10 @@ module EE
   module Projects
     module GroupLinks
       module DestroyService
-        def execute(group_link)
-          raise NotImplementedError unless defined?(super)
+        extend ::Gitlab::Utils::Override
 
+        override :execute
+        def execute(group_link)
           super.tap { |link| log_audit_event(link) if link && !link&.persisted? }
         end
 

ee/app/services/ee/projects/hashed_storage/migrate_attachments_service.rb

@@ -2,9 +2,10 @@ module EE
   module Projects
     module HashedStorage
       module MigrateAttachmentsService
-        def execute
-          raise NotImplementedError.new unless defined?(super)
+        extend ::Gitlab::Utils::Override
 
+        override :execute
+        def execute
           super do
             ::Geo::HashedStorageAttachmentsEventStore.new(
               project,

ee/app/services/ee/projects/hashed_storage/migrate_repository_service.rb

@@ -2,9 +2,10 @@ module EE
   module Projects
     module HashedStorage
       module MigrateRepositoryService
-        def execute
-          raise NotImplementedError.new unless defined?(super)
+        extend ::Gitlab::Utils::Override
 
+        override :execute
+        def execute
           super do
             ::Geo::HashedStorageMigratedEventStore.new(
               project,

ee/app/services/ee/projects/transfer_service.rb

 module EE
   module Projects
     module TransferService
+      extend ::Gitlab::Utils::Override
+
       private
 
+      override :execute_system_hooks
       def execute_system_hooks
-        raise NotImplementedError unless defined?(super)
-
         super
 
         EE::Audit::ProjectChangesAuditor.new(current_user, project).execute

ee/app/services/ee/projects/update_service.rb

 module EE
   module Projects
     module UpdateService
-      def execute
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :execute
+      def execute
         unless project.feature_available?(:repository_mirrors)
           params.delete(:mirror)
           params.delete(:mirror_user_id)

ee/app/services/ee/protected_branches/access_level_params.rb

 module EE
   module ProtectedBranches
     module AccessLevelParams
-      def access_levels
-        raise NotImplementedError unless defined?(super)
+      extend ::Gitlab::Utils::Override
 
+      override :access_levels
+      def access_levels
         ce_style_access_level + ee_style_access_levels
       end
 
@@ -17,9 +18,8 @@ module EE
 
       private
 
+      override :use_default_access_level?
       def use_default_access_level?(params)
-        raise NotImplementedError unless defined?(super)
-
         params[:"allowed_to_#{type}"].blank?
       end
 

ee/app/services/ee/protected_branches/api_service.rb

 module EE
   module ProtectedBranches
     module ApiService
+      extend ::Gitlab::Utils::Override
+
       GroupsNotAccessibleError = Class.new(StandardError)
       UsersNotAccessibleError = Class.new(StandardError)
 
+      override :create
       def create
-        raise NotImplementedError unless defined?(super)
-
         super
       rescue ::EE::ProtectedBranches::ApiService::GroupsNotAccessibleError,
              ::EE::ProtectedBranches::ApiService::UsersNotAccessibleError
@@ -18,9 +19,8 @@ module EE
 
       private
 
+      override :verify_params!
       def verify_params!
-        raise NotImplementedError unless defined?(super)
-
         raise GroupsNotAccessibleError.new unless groups_accessible?
         raise UsersNotAccessibleError.new unless users_accessible?
       end

ee/lib/ee/gitlab/auth/result.rb

@@ -2,9 +2,10 @@ module EE
   module Gitlab
     module Auth
       module Result
-        def success?
-          raise NotImplementedError.new unless defined?(super)
+        extend ::Gitlab::Utils::Override
 
+        override :success?
+        def success?
           type == :geo || super
         end
 

ee/lib/ee/gitlab/git_access.rb

@@ -2,18 +2,17 @@ module EE
   module Gitlab
     module GitAccess
       prepend GeoGitAccess
+      extend ::Gitlab::Utils::Override
 
+      override :check
       def check(cmd, changes)
-        raise NotImplementedError.new unless defined?(super)
-
         check_geo_license!
 
         super
       end
 
+      override :can_read_project?
       def can_read_project?
-        raise NotImplementedError.new unless defined?(super)
-
         return true if geo?
 
         super
@@ -21,9 +20,8 @@ module EE
 
       protected
 
+      override :user
       def user
-        raise NotImplementedError.new unless defined?(super)
-
         return nil if geo?
 
         super
@@ -31,17 +29,15 @@ module EE
 
       private
 
+      override :check_download_access!
       def check_download_access!
-        raise NotImplementedError.new unless defined?(super)
-
         return if geo?
 
         super
       end
 
+      override :check_active_user!
       def check_active_user!
-        raise NotImplementedError.new unless defined?(super)
-
         return if geo?
 
         super

lib/gitlab/utils/override.rb

+module Gitlab
+  module Utils
+    module Override
+      class Extension
+        def self.verify_class!(klass, method_name)
+          instance_method_defined?(klass, method_name) ||
+            raise(
+              NotImplementedError.new(
+                "#{klass}\##{method_name} doesn't exist!"))
+        end
+
+        def self.instance_method_defined?(klass, name, include_super: true)
+          klass.instance_methods(include_super).include?(name) ||
+            klass.private_instance_methods(include_super).include?(name)
+        end
+
+        attr_reader :subject
+
+        def initialize(subject)
+          @subject = subject
+        end
+
+        def add_method_name(method_name)
+          method_names << method_name
+        end
+
+        def add_class(klass)
+          classes << klass
+        end
+
+        def verify!
+          classes.each do |klass|
+            index = klass.ancestors.index(subject)
+            parents = klass.ancestors.drop(index + 1)
+
+            method_names.each do |method_name|
+              parents.any? do |parent|
+                self.class.instance_method_defined?(
+                  parent, method_name, include_super: false)
+              end ||
+                raise(
+                  NotImplementedError.new(
+                    "#{klass}\##{method_name} doesn't exist!"))
+            end
+          end
+        end
+
+        private
+
+        def method_names
+          @method_names ||= []
+        end
+
+        def classes
+          @classes ||= []
+        end
+      end
+
+      # Instead of writing patterns like this:
+      #
+      #     def f
+      #       raise NotImplementedError unless defined?(super)
+      #
+      #       true
+      #     end
+      #
+      # We could write it like:
+      #
+      #     extend ::Gitlab::Utils::Override
+      #
+      #     override :f
+      #     def f
+      #       true
+      #     end
+      #
+      # This would make sure we're overriding something. See:
+      # https://gitlab.com/gitlab-org/gitlab-ee/issues/1819
+      def override(method_name)
+        return unless ENV['STATIC_VERIFICATION']
+
+        if is_a?(Class)
+          Extension.verify_class!(self, method_name)
+        else # We delay the check for modules
+          Override.extensions[self] ||= Extension.new(self)
+          Override.extensions[self].add_method_name(method_name)
+        end
+      end
+
+      def included(base = nil)
+        return super if base.nil? # Rails concern, ignoring it
+
+        super
+
+        if base.is_a?(Class) # We could check for Class in `override`
+          # This could be `nil` if `override` was never called
+          Override.extensions[self]&.add_class(base)
+        end
+      end
+
+      alias_method :prepended, :included
+
+      def self.extensions
+        @extensions ||= {}
+      end
+
+      def self.verify!
+        extensions.values.each(&:verify!)
+      end
+    end
+  end
+end

lib/tasks/dev.rake

@@ -7,4 +7,9 @@ namespace :dev do
     Rake::Task["gitlab:setup"].invoke
     Rake::Task["gitlab:shell:setup"].invoke
   end
+
+  desc "GitLab | Eager load application"
+  task load: :environment do
+    Rails.application.eager_load!
+  end
 end

lib/tasks/lint.rake

 unless Rails.env.production?
   namespace :lint do
+    task :static_verification_env do
+      ENV['STATIC_VERIFICATION'] = 'true'
+    end
+
+    desc "GitLab | lint | Static verification"
+    task static_verification: %w[
+      lint:static_verification_env
+      dev:load
+    ] do
+      Gitlab::Utils::Override.verify!
+    end
+
     desc "GitLab | lint | Lint JavaScript files using ESLint"
     task :javascript do
       Rake::Task['eslint'].invoke

scripts/static-analysis

@@ -10,9 +10,10 @@ tasks = [
   %w[bundle exec license_finder],
   %w[yarn run eslint],
   %w[bundle exec rubocop --parallel],
-  %w[scripts/lint-conflicts.sh],
   %w[bundle exec rake gettext:lint],
-  %w[scripts/lint-changelog-yaml]
+  %w[bundle exec rake lint:static_verification],
+  %w[scripts/lint-changelog-yaml],
+  %w[scripts/lint-conflicts.sh]
 ]
 
 failed_tasks = tasks.reduce({}) do |failures, task|

spec/lib/gitlab/utils/override_spec.rb

+require 'spec_helper'
+
+describe Gitlab::Utils::Override do
+  let(:base) { Struct.new(:good) }
+
+  let(:derived) { Class.new(base).tap { |m| m.extend described_class } }
+  let(:extension) { Module.new.tap { |m| m.extend described_class } }
+
+  let(:prepending_class) { base.tap { |m| m.prepend extension } }
+  let(:including_class) { base.tap { |m| m.include extension } }
+
+  let(:klass) { subject }
+
+  def good(mod)
+    mod.module_eval do
+      override :good
+      def good
+        super.succ
+      end
+    end
+
+    mod
+  end
+
+  def bad(mod)
+    mod.module_eval do
+      override :bad
+      def bad
+        true
+      end
+    end
+
+    mod
+  end
+
+  shared_examples 'checking as intended' do
+    it 'checks ok for overriding method' do
+      good(subject)
+      result = klass.new(0).good
+
+      expect(result).to eq(1)
+      described_class.verify!
+    end
+
+    it 'raises NotImplementedError when it is not overriding anything' do
+      expect do
+        bad(subject)
+        klass.new(0).bad
+        described_class.verify!
+      end.to raise_error(NotImplementedError)
+    end
+  end
+
+  shared_examples 'nothing happened' do
+    it 'does not complain when it is overriding something' do
+      good(subject)
+      result = klass.new(0).good
+
+      expect(result).to eq(1)
+      described_class.verify!
+    end
+
+    it 'does not complain when it is not overriding anything' do
+      bad(subject)
+      result = klass.new(0).bad
+
+      expect(result).to eq(true)
+      described_class.verify!
+    end
+  end
+
+  before do
+    # Make sure we're not touching the internal cache
+    allow(described_class).to receive(:extensions).and_return({})
+  end
+
+  describe '#override' do
+    context 'when STATIC_VERIFICATION is set' do
+      before do
+        stub_env('STATIC_VERIFICATION', 'true')
+      end
+
+      context 'when subject is a class' do
+        subject { derived }
+
+        it_behaves_like 'checking as intended'
+      end
+
+      context 'when subject is a module, and class is prepending it' do
+        subject { extension }
+        let(:klass) { prepending_class }
+
+        it_behaves_like 'checking as intended'
+      end
+
+      context 'when subject is a module, and class is including it' do
+        subject { extension }
+        let(:klass) { including_class }
+
+        it 'raises NotImplementedError because it is not overriding it' do
+          expect do
+            good(subject)
+            klass.new(0).good
+            described_class.verify!
+          end.to raise_error(NotImplementedError)
+        end
+
+        it 'raises NotImplementedError when it is not overriding anything' do
+          expect do
+            bad(subject)
+            klass.new(0).bad
+            described_class.verify!
+          end.to raise_error(NotImplementedError)
+        end
+      end
+    end
+  end
+
+  context 'when STATIC_VERIFICATION is not set' do
+    before do
+      stub_env('STATIC_VERIFICATION', nil)
+    end
+
+    context 'when subject is a class' do
+      subject { derived }
+
+      it_behaves_like 'nothing happened'
+    end
+
+    context 'when subject is a module, and class is prepending it' do
+      subject { extension }
+      let(:klass) { prepending_class }
+
+      it_behaves_like 'nothing happened'
+    end
+
+    context 'when subject is a module, and class is including it' do
+      subject { extension }
+      let(:klass) { including_class }
+
+      it 'does not complain when it is overriding something' do
+        good(subject)
+        result = klass.new(0).good
+
+        expect(result).to eq(0)
+        described_class.verify!
+      end
+
+      it 'does not complain when it is not overriding anything' do
+        bad(subject)
+        result = klass.new(0).bad
+
+        expect(result).to eq(true)
+        described_class.verify!
+      end
+    end
+  end
+end