Let us do dependency injection with Guice, which is a lightweight framework suggested by AWS.

1. Add Maven dependency for Guice:

<dependency>
    <groupId>com.google.inject</groupId>
    <artifactId>guice</artifactId>
    <version>4.2.0</version>
</dependency>

2. Create the Guice configuration class to bind interfaces to implementation:

public class ApplicationModule extends AbstractModule {
    protected final void configure() {
        bind(IAMService.class).to(IAMServiceImpl.class);
    }
}

3. Configure the handler class for using Guice:

public final class MyLambdaHandler implements RequestHandler<IAMOperationRequest, IAMOperationResponse> {

    private static final Injector INJECTOR =
            Guice.createInjector(new ApplicationModule());

    private IAMService service;

    public MyLambdaHandler() {
        INJECTOR.injectMembers(this);
        Objects.requireNonNull(service);
    }

    @Inject
    public void setService(final IAMService service) {
        this.service = service;
    }

I created a static Injector class and initialized it with our Guice configuration class. I added a default constructor to add this class to be injected by Guice. Objects.requireNonNull verifies if the implementation was injected successfully. I annotated it with Java's @Inject annotation for Guice to inject dependency.  

Let us write unit tests for our code. 

1. Add Maven dependency for JUnit and Mockito:

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>2.21.0</version>
    <scope>test</scope>
</dependency>

2. Create a simple test class for the handler that checks if the service implementation is injected:

package tech.heartin.books.serverlesscookbook;

import org.junit.Test;

public class MyLambdaHandlerTest {
    @Test
    public void testDependencies() throws Exception {
        MyLambdaHandler testHandler = new MyLambdaHandler();
    }
}

3. Create a test class for the service class that uses Mockito to mock AWS calls:

@RunWith(MockitoJUnitRunner.class)
public class IAMServiceImplTest {

    @Mock
    private AmazonIdentityManagement iamClient;

    private IAMService service;

    @Before
    public void setUp() {
        service = new IAMServiceImpl(iamClient);
        Objects.requireNonNull(service);
    }
    // Actual tests not shown here
}

4. Add the test method for create user:

@Test
public void testCreateUser() {
    IAMOperationResponse expectedResponse = new IAMOperationResponse(
            "Created user test_user", null);
    when(iamClient.createUser(any()))
            .thenReturn(new CreateUserResult()
                    .withUser(new User().withUserName("test_user")));
    IAMOperationResponse actualResponse 
            = service.createUser("test_user");
    Assert.assertEquals(expectedResponse, actualResponse);
}

5. Add the test method to check user:

@Test
public void testCheckUser() {
    IAMOperationResponse expectedResponse = new IAMOperationResponse(
            "User test_user exist", null);
    when(iamClient.listUsers(any()))
            .thenReturn(getListUsersResult());
    IAMOperationResponse actualResponse 
            = service.checkUser("test_user");
    Assert.assertEquals(expectedResponse, actualResponse);
}

private ListUsersResult getListUsersResult() {
    ListUsersResult result = new ListUsersResult();
    result.getUsers().add(new User().withUserName("test_user"));

6. Add the test method to delete user:

@Test
public void testDeleteUser() {
    IAMOperationResponse expectedResponse = new IAMOperationResponse(
            "Deleted user test_user", null);
    when(iamClient.deleteUser(any()))
            .thenReturn(new DeleteUserResult());
    IAMOperationResponse actualResponse 
            = service.deleteUser("test_user");
    Assert.assertEquals(expectedResponse, actualResponse);
}

7. To Package, deploy, and verify, follow the Using AWS SDK, Amazon CloudFormation and AWS CLI with Lambda recipe, and package, deploy, and verify by invoking the Lambda.