MockInjectionStrategy
Date: 2015-09-18

org.mockito.internal.configuration.injection

## Class MockInjectionStrategy

- java.lang.Object
- - org.mockito.internal.configuration.injection.MockInjectionStrategy

- Direct Known Subclasses:
    ConstructorInjection, PropertyAndSetterInjection, SpyOnInjectedFieldsHandler

      public abstract class MockInjectionStrategy
      extends java.lang.Object

  Injector strategy contract

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `MockInjectionStrategy()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static MockInjectionStrategy` | `nop()` NOP Strategy that will always try the next strategy.
    `boolean` | `process(java.lang.reflect.Field onField, java.lang.Object fieldOwnedBy, java.util.Set<java.lang.Object> mockCandidates)` Actually inject mockCandidates on field.
    `protected abstract boolean` | `processInjection(java.lang.reflect.Field field, java.lang.Object fieldOwner, java.util.Set<java.lang.Object> mockCandidates)` Process actual injection.
    `MockInjectionStrategy` | `thenTry(MockInjectionStrategy strategy)` Enqueue next injection strategy.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### MockInjectionStrategy

          public MockInjectionStrategy()

  - ### Method Detail

    - #### nop

          public static final MockInjectionStrategy nop()

      NOP Strategy that will always try the next strategy.

    - #### thenTry

          public MockInjectionStrategy thenTry(MockInjectionStrategy strategy)

      Enqueue next injection strategy.

      The implementation should take care of the actual calling if required.

      Parameters:
        `strategy` - Queued strategy.
      Returns:
        The passed strategy instance to allow chaining.

    - #### process

          public boolean process(java.lang.reflect.Field onField,
                        java.lang.Object fieldOwnedBy,
                        java.util.Set<java.lang.Object> mockCandidates)

      Actually inject mockCandidates on field.

      Actual algorithm is defined in the implementations of `processInjection(Field, Object, Set)`. However if injection occurred successfully, the process should return `true`, and `false` otherwise.

      The code takes care of calling the next strategy if available and if of course if required

      Parameters:
        `onField` - Field needing injection.
        `fieldOwnedBy` - The owning instance of the field.
        `mockCandidates` - A set of mock candidate, that might be injected.
      Returns:
        `true` if successful, `false` otherwise.

    - #### processInjection

          protected abstract boolean processInjection(java.lang.reflect.Field field,
                                 java.lang.Object fieldOwner,
                                 java.util.Set<java.lang.Object> mockCandidates)

      Process actual injection.

      Don't call this method directly, instead call `process(Field, Object, Set)`

      Parameters:
        `field` - Field needing injection
        `fieldOwner` - Field owner instance.
        `mockCandidates` - Pool of mocks to inject.
      Returns:
        `true` if injection occurred, `false` otherwise