inspec/test/unit/resources/aws_iam_user_test.rb

require "helper"
require "inspec/resource"
require "resources/aws/aws_iam_user"

require "resource_support/aws"
require "resources/aws/aws_iam_user"

# MAUIB = MockAwsIamUserBackend
# Abbreviation not used outside this file

#=============================================================================#
#                            Constructor Tests
#=============================================================================#
class AwsIamUserConstructorTest < Minitest::Test

  def setup
    AwsIamUser::BackendFactory.select(MAIUB::Three)
  end

  def test_empty_params_throws_exception
    assert_raises(ArgumentError) { AwsIamUser.new }
  end

  def test_accepts_username_as_scalar
    AwsIamUser.new("erin")
  end

  def test_accepts_username_as_hash
    AwsIamUser.new(username: "erin")
  end

  def test_rejects_unrecognized_params
    assert_raises(ArgumentError) { AwsIamUser.new(shoe_size: 9) }
  end
end

#=============================================================================#
#                               Search / Recall
#=============================================================================#
class AwsIamUserRecallTest < Minitest::Test
  def setup
    AwsIamUser::BackendFactory.select(MAIUB::Three)
  end

  def test_search_miss_is_not_an_exception
    user = AwsIamUser.new("tommy")
    refute user.exists?
  end

  def test_search_hit_via_scalar_works
    user = AwsIamUser.new("erin")
    assert user.exists?
    assert_equal("erin", user.username)
  end

  def test_search_hit_via_hash_works
    user = AwsIamUser.new(username: "erin")
    assert user.exists?
    assert_equal("erin", user.username)
  end
end

#=============================================================================#
#                                Properties
#=============================================================================#

class AwsIamUserPropertiesTest < Minitest::Test
  def setup
    AwsIamUser::BackendFactory.select(MAIUB::Three)
  end

  def test_property_attached_policies
    noone = AwsIamUser.new("nonesuch")
    assert_empty(noone.attached_policy_names)
    assert_empty(noone.attached_policy_arns)

    erin = AwsIamUser.new("erin")
    assert_empty(erin.attached_policy_names)
    assert_empty(erin.attached_policy_arns)

    leslie = AwsIamUser.new("leslie")
    assert_equal(1, leslie.attached_policy_names.count)
    assert_includes(leslie.attached_policy_names, "AdministratorAccess")
    assert_equal(1, leslie.attached_policy_arns.count)
    assert_includes(leslie.attached_policy_arns, "arn:aws:iam::aws:policy/AdministratorAccess")

    jared = AwsIamUser.new("jared")
    assert_equal(2, jared.attached_policy_names.count)
    assert_includes(jared.attached_policy_names, "ReadOnlyAccess")
    assert_equal(2, jared.attached_policy_arns.count)
    assert_includes(jared.attached_policy_arns, "arn:aws:iam::aws:policy/ReadOnlyAccess")
  end

  def test_property_inline_policies
    noone = AwsIamUser.new("nonesuch")
    assert_empty(noone.inline_policy_names)

    erin = AwsIamUser.new("erin")
    assert_empty(erin.inline_policy_names)

    leslie = AwsIamUser.new("leslie")
    assert_equal(2, leslie.inline_policy_names.count)
    assert_includes(leslie.inline_policy_names, "leslie-inline-01")
    assert_includes(leslie.inline_policy_names, "leslie-inline-02")

    jared = AwsIamUser.new("jared")
    assert_equal(1, jared.inline_policy_names.count)
    assert_includes(jared.inline_policy_names, "jared-inline-01")
  end

  #-----------------------------------------------------#
  # username property
  #-----------------------------------------------------#
  def test_property_username_correct_on_hit
    user = AwsIamUser.new("erin")
    assert_equal("erin", user.username)
  end

  def test_property_username_correct_on_miss
    user = AwsIamUser.new("nonesuch")
    assert_equal("nonesuch", user.username)
  end

  #-----------------------------------------------------#
  # access_keys property
  #-----------------------------------------------------#
  def test_property_access_keys_positive
    keys = AwsIamUser.new("erin").access_keys
    assert_kind_of(Array, keys)
    assert_equal(keys.length, 2)
    # We don't currently promise that the results
    # will be InSpec resource objects.
    # assert_kind_of(AwsIamAccessKey, keys.first)
  end

  def test_property_access_keys_negative
    keys = AwsIamUser.new("leslie").access_keys
    assert_kind_of(Array, keys)
    assert(keys.empty?)
  end
end

#=============================================================================#
#                                Matchers
#=============================================================================#

class AwsIamUserMatchersTest < Minitest::Test
  def setup
    AwsIamUser::BackendFactory.select(MAIUB::Three)
  end

  def test_matcher_mfa_positive
    user = AwsIamUser.new("erin")
    assert_equal(true, user.has_mfa_enabled)
    assert_equal(true, user.has_mfa_enabled?)
  end

  def test_matcher_mfa_negative
    user = AwsIamUser.new("leslie")
    assert_equal(false, user.has_mfa_enabled)
    assert_equal(false, user.has_mfa_enabled?)
  end

  def test_matcher_password_positive
    user = AwsIamUser.new("erin")
    assert_equal(true, user.has_console_password)
    assert_equal(true, user.has_console_password?)
  end

  def test_matcher_password_negative
    user = AwsIamUser.new("leslie")
    assert_equal(false, user.has_console_password)
    assert_equal(false, user.has_console_password?)
  end

  def test_matcher_has_attached_policies
    assert_nil(AwsIamUser.new("nonesuch").has_attached_policies?)
    refute(AwsIamUser.new("erin").has_attached_policies?)
    assert(AwsIamUser.new("leslie").has_attached_policies?)
    assert(AwsIamUser.new("jared").has_attached_policies?)
  end

  def test_matcher_has_inline_policies
    assert_nil(AwsIamUser.new("nonesuch").has_inline_policies?)
    refute(AwsIamUser.new("erin").has_inline_policies?)
    assert(AwsIamUser.new("leslie").has_inline_policies?)
    assert(AwsIamUser.new("jared").has_inline_policies?)
  end

end

#=============================================================================#
#                               Test Fixtures
#=============================================================================#

module MAIUB
  class Three < AwsBackendBase
    def get_user(criteria)
      people = {
        "erin" => OpenStruct.new({
          user: OpenStruct.new({
            arn: "arn:aws:iam::123456789012:user/erin",
            create_date: Time.parse("2016-09-21T23:03:13Z"),
            path: "/",
            user_id: "AKIAIOSFODNN7EXAERIN",
            user_name: "erin",
          }),
        }),
        "leslie" => OpenStruct.new({
          user: OpenStruct.new({
            arn: "arn:aws:iam::123456789012:user/leslie",
            create_date: Time.parse("2017-09-21T23:03:13Z"),
            path: "/",
            user_id: "AKIAIOSFODNN7EXAERIN",
            user_name: "leslie",
          }),
        }),
        "jared" => OpenStruct.new({
          user: OpenStruct.new({
            arn: "arn:aws:iam::123456789012:user/jared",
            create_date: Time.parse("2017-09-21T23:03:13Z"),
            path: "/",
            user_id: "AKIAIOSFODNN7EXAERIN",
            user_name: "jared",
          }),
        }),
      }
      raise Aws::IAM::Errors::NoSuchEntity.new(nil, nil) unless people.key?(criteria[:user_name])
      people[criteria[:user_name]]
    end

    def get_login_profile(criteria)
      # Leslie has no password
      # Jared's is expired
      people = {
        "erin" => OpenStruct.new({
          login_profile: OpenStruct.new({
            user_name: "erin",
            password_reset_required: false,
            create_date: Time.parse("2016-09-21T23:03:13Z"),
          }),
        }),
        "jared" => OpenStruct.new({
          login_profile: OpenStruct.new({
            user_name: "jared",
            password_reset_required: true,
            create_date: Time.parse("2017-09-21T23:03:13Z"),
          }),
        }),
      }
      raise Aws::IAM::Errors::NoSuchEntity.new(nil, nil) unless people.key?(criteria[:user_name])
      people[criteria[:user_name]]
    end

    def list_mfa_devices(criteria)
      # Erin has 2, one soft and one hw
      # Leslie has none
      # Jared has one soft
      people = {
        "erin" => OpenStruct.new({
          mfa_devices: [
            OpenStruct.new({
              user_name: "erin",
              serial_number: "arn:blahblahblah",
              enable_date: Time.parse("2016-09-21T23:03:13Z"),
            }),
            OpenStruct.new({
              user_name: "erin",
              serial_number: "1234567890",
              enable_date: Time.parse("2016-09-21T23:03:13Z"),
            }),
          ],
        }),
        "leslie" => OpenStruct.new({ mfa_devices: [] }),
        "jared" => OpenStruct.new({
          mfa_devices: [
            OpenStruct.new({
              user_name: "jared",
              serial_number: "arn:blahblahblah",
              enable_date: Time.parse("2016-09-21T23:03:13Z"),
            }),
          ],
        }),
      }
      people[criteria[:user_name]]
    end

    def list_access_keys(criteria)
      # Erin has 2
      # Leslie has none
      # Jared has one
      people = {
        "erin" => OpenStruct.new({
          access_key_metadata: [
            OpenStruct.new({
              user_name: "erin",
              access_key_id: "AKIA111111111EXAMPLE",
              create_date: Time.parse("2016-09-21T23:03:13Z"),
              status: "Active",
            }),
            OpenStruct.new({
              user_name: "erin",
              access_key_id: "AKIA222222222EXAMPLE",
              create_date: Time.parse("2016-09-21T23:03:13Z"),
              status: "Active",
            }),
          ],
        }),
        "leslie" => OpenStruct.new({ access_key_metadata: [] }),
        "jared" => OpenStruct.new({
          access_key_metadata: [
            OpenStruct.new({
              user_name: "jared",
              access_key_id: "AKIA3333333333EXAMPLE",
              create_date: Time.parse("2017-10-21T23:03:13Z"),
              status: "Active",
            }),
          ],
        }),
      }
      people[criteria[:user_name]]
    end

    def list_user_policies(query)
      people = {
        "erin" => Aws::IAM::Types::ListUserPoliciesResponse.new(
          policy_names: []
        ),
        "leslie" => Aws::IAM::Types::ListUserPoliciesResponse.new(
          policy_names: ["leslie-inline-01", "leslie-inline-02"]
        ),
        "jared" => Aws::IAM::Types::ListUserPoliciesResponse.new(
          policy_names: ["jared-inline-01"]
        ),
      }
      people[query[:user_name]]
    end

    def list_attached_user_policies(query)
      people = {
        "erin" => Aws::IAM::Types::ListAttachedUserPoliciesResponse.new(
          attached_policies: []
        ),
        "leslie" => Aws::IAM::Types::ListAttachedUserPoliciesResponse.new(
          attached_policies: [
            {
              policy_arn: "arn:aws:iam::aws:policy/AdministratorAccess",
              policy_name: "AdministratorAccess",
            },
          ]
        ),
        "jared" => Aws::IAM::Types::ListAttachedUserPoliciesResponse.new(
          attached_policies: [
            {
              policy_arn: "arn:aws:iam::aws:policy/ReadOnlyAccess",
              policy_name: "ReadOnlyAccess",
            },
            {
              policy_arn: "arn:aws:iam::123456789012:policy/some-policy",
              policy_name: "some-policy",
            },
          ]
        ),
      }
      people[query[:user_name]]
    end

  end
end