runbooks 0.2.5__py3-none-any.whl → 0.7.0__py3-none-any.whl

runbooks/inventory/tests/test_lambda_list_functions.py

@@ -0,0 +1,86 @@
+import pytest
+from common_test_data import CredentialResponseData, get_all_my_functions_test_result_dict
+from common_test_functions import _amend_create_boto3_session, _amend_make_api_call, _amend_make_api_call_specific
+from lambda_list_functions import collect_all_my_functions, fix_my_functions
+
+# CredentialList = test_get_all_credentials()
+# This is what the response from the tested function should look like, given the parameters supplied
+
+"""
+Pass in the parameters as dictionary with operation names and what test results I should get back
+"""
+function_parameters = {"CredentialList": CredentialResponseData, "pFragments": ["python3.9", "Metric"], "pverbose": 20}
+
+
+@pytest.mark.parametrize(
+    "parameters, test_value_dict",
+    [
+        (function_parameters, get_all_my_functions_test_result_dict),
+        # (RootOnlyParams, ),
+        # str(1993),
+        # json.dumps({"SecretString": "my-secret"}),
+        # json.dumps([2, 3, 5, 7, 11, 13, 17, 19]),
+        # KeyError("How dare you touch my secret!"),
+        # ValueError("Oh my goodness you even have the guts to repeat it!!!"),
+    ],
+)
+def test_all_my_functions(parameters, test_value_dict, mocker):
+    """
+    Description:
+    @param parameters: the expected parameters into the function
+    @param mocker: the mock object
+    @return:
+    """
+    CredentialList = parameters["CredentialList"]
+    pFragments = parameters["pFragments"]
+    verbose = parameters["pverbose"]
+    test_data = {"FunctionName": "all_my_functions", "AccountSpecific": True, "RegionSpecific": True}
+    # _amend_create_boto3_session(test_data, mocker)
+    # pass
+    # _amend_make_api_call(test_data, test_value_dict, mocker)
+    _amend_make_api_call_specific(test_data, test_value_dict, mocker)
+
+    # if isinstance(test_value, Exception):
+    # 	print("Expected Error...")
+    # 	with pytest.raises(type(test_value)) as error:
+    # 		all_my_functions(CredentialList, pFragments, verbose)
+    # 	result = error
+    # else:
+    result = collect_all_my_functions(CredentialList, pFragments, verbose)
+
+    print("Result:", result)
+    print()
+
+
+"""
+import boto3
+from unittest.mock import patch, MagicMock
+
+
+# Your application code
+def get_lambda_functions():
+	session = boto3.Session('LZ1', region_name='us-east-2')
+	lambda_client = session.client('lambda')
+	return lambda_client.list_functions()
+
+
+# Your mock method
+def mock_list_functions(*args, **kwargs):
+	print("Inside the mocked function!")
+	# Access the session info here (if it's passed or globally accessible)
+	print()
+	creds = args[1]['test'].get_credentials()
+	return {'Functions': [{'FunctionName': 'mocked_function_1'}, {'FunctionName': 'mocked_function_2'}]}
+
+
+# Your test code
+def test_get_lambda_functions():
+	with patch.object(boto3.Session, 'client') as mock_client:
+		mock_lambda_client = MagicMock()
+		addl_params = {'test': boto3.Session(), 'account': '11111'}
+		mock_lambda_client.list_functions = mock_list_functions('lambda', addl_params)
+		mock_client.return_value = mock_lambda_client
+
+		result = get_lambda_functions()
+		assert result == {'Functions': [{'FunctionName': 'mocked_function_1'}, {'FunctionName': 'mocked_function_2'}]}
+"""

runbooks/inventory/tests/test_moto_integration_example.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""
+Integration Test Example for AWS Cloud Foundations Inventory Scripts
+
+This demonstrates how to use moto for AWS service mocking in inventory script testing.
+This follows the KISS principle - simple, focused tests that validate core functionality.
+
+**Test Strategy:**
+- Use moto to mock AWS services (no real AWS calls)
+- Test individual functions in isolation
+- Focus on core logic validation
+- Demonstrate integration testing patterns
+
+**Markers:**
+- @pytest.mark.integration: Integration tests using moto
+- @pytest.mark.aws_service: AWS service-specific tests
+- @pytest.mark.inventory: Inventory collection tests
+"""
+
+import boto3
+import pytest
+from moto import mock_aws
+
+# Test Markers
+pytestmark = [pytest.mark.integration, pytest.mark.aws_service, pytest.mark.inventory]
+
+
+class TestEC2IntegrationWithMoto:
+    """
+    Integration tests for EC2-related inventory scripts using moto.
+
+    These tests demonstrate how to mock AWS EC2 service for testing
+    inventory collection without requiring real AWS credentials.
+    """
+
+    @mock_aws
+    def test_ec2_describe_instances_with_mocked_service(self):
+        """
+        Test EC2 instance discovery with mocked EC2 service.
+
+        This test demonstrates:
+        - Moto EC2 service mocking
+        - Instance creation and discovery
+        - Basic inventory collection patterns
+        """
+        # Create mock EC2 client
+        ec2_client = boto3.client("ec2", region_name="us-east-1")
+
+        # Create test instances
+        response = ec2_client.run_instances(
+            ImageId="ami-12345678",
+            MinCount=2,
+            MaxCount=2,
+            InstanceType="t2.micro",
+            TagSpecifications=[
+                {
+                    "ResourceType": "instance",
+                    "Tags": [
+                        {"Key": "Environment", "Value": "test"},
+                        {"Key": "Project", "Value": "inventory-testing"},
+                    ],
+                }
+            ],
+        )
+
+        # Test instance discovery
+        instances_response = ec2_client.describe_instances()
+        reservations = instances_response["Reservations"]
+
+        # Validate results
+        assert len(reservations) == 1, "Should have one reservation"
+        instances = reservations[0]["Instances"]
+        assert len(instances) == 2, "Should have two instances"
+
+        # Validate instance properties
+        for instance in instances:
+            assert instance["InstanceType"] == "t2.micro"
+            assert instance["State"]["Name"] == "running"
+
+            # Check tags
+            tags = {tag["Key"]: tag["Value"] for tag in instance.get("Tags", [])}
+            assert tags["Environment"] == "test"
+            assert tags["Project"] == "inventory-testing"
+
+    @mock_aws
+    def test_vpc_discovery_with_moto(self):
+        """
+        Test VPC discovery with mocked EC2 service.
+
+        Demonstrates VPC and subnet inventory collection patterns.
+        """
+        ec2_client = boto3.client("ec2", region_name="us-west-2")
+
+        # Create test VPC
+        vpc_response = ec2_client.create_vpc(CidrBlock="10.0.0.0/16")
+        vpc_id = vpc_response["Vpc"]["VpcId"]
+
+        # Tag the VPC
+        ec2_client.create_tags(
+            Resources=[vpc_id], Tags=[{"Key": "Name", "Value": "test-vpc"}, {"Key": "Environment", "Value": "testing"}]
+        )
+
+        # Create test subnet
+        subnet_response = ec2_client.create_subnet(VpcId=vpc_id, CidrBlock="10.0.1.0/24")
+        subnet_id = subnet_response["Subnet"]["SubnetId"]
+
+        # Test VPC discovery
+        vpcs_response = ec2_client.describe_vpcs()
+        vpcs = vpcs_response["Vpcs"]
+
+        # Validate VPC discovery
+        test_vpc = next((vpc for vpc in vpcs if vpc["VpcId"] == vpc_id), None)
+        assert test_vpc is not None, "Test VPC should be discovered"
+        assert test_vpc["CidrBlock"] == "10.0.0.0/16"
+
+        # Test subnet discovery
+        subnets_response = ec2_client.describe_subnets(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])
+        subnets = subnets_response["Subnets"]
+
+        assert len(subnets) == 1, "Should find one subnet"
+        assert subnets[0]["SubnetId"] == subnet_id
+        assert subnets[0]["CidrBlock"] == "10.0.1.0/24"
+
+
+class TestOrganizationsIntegrationWithMoto:
+    """
+    Integration tests for AWS Organizations functionality using moto.
+
+    These tests demonstrate testing patterns for organization structure
+    discovery and policy management.
+    """
+
+    @mock_aws
+    def test_organizations_basic_structure(self):
+        """
+        Test basic AWS Organizations structure discovery.
+
+        Note: moto's Organizations support is limited, but this demonstrates
+        the testing pattern for when more features become available.
+        """
+        org_client = boto3.client("organizations", region_name="us-east-1")
+
+        try:
+            # Attempt to create organization (may not be fully supported in moto)
+            response = org_client.create_organization(FeatureSet="ALL")
+
+            # Test root discovery
+            roots_response = org_client.list_roots()
+            roots = roots_response["Roots"]
+
+            assert len(roots) >= 1, "Should have at least one root"
+
+        except Exception as e:
+            # Expected - moto has limited Organizations support
+            # This demonstrates the test structure for when support improves
+            pytest.skip(f"Moto Organizations support limited: {e}")
+
+
+class TestIAMIntegrationWithMoto:
+    """
+    Integration tests for IAM-related inventory scripts using moto.
+
+    Demonstrates testing patterns for IAM role and policy discovery.
+    """
+
+    @mock_aws
+    def test_iam_role_discovery(self):
+        """
+        Test IAM role discovery with mocked IAM service.
+
+        This demonstrates testing patterns for IAM inventory collection.
+        """
+        iam_client = boto3.client("iam", region_name="us-east-1")
+
+        # Create test role
+        import json
+
+        assume_role_policy = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {"Effect": "Allow", "Principal": {"Service": "ec2.amazonaws.com"}, "Action": "sts:AssumeRole"}
+            ],
+        }
+
+        iam_client.create_role(
+            RoleName="test-inventory-role",
+            AssumeRolePolicyDocument=json.dumps(assume_role_policy),
+            Description="Test role for inventory testing",
+            Tags=[{"Key": "Environment", "Value": "test"}, {"Key": "Purpose", "Value": "inventory-testing"}],
+        )
+
+        # Test role discovery
+        roles_response = iam_client.list_roles()
+        roles = roles_response["Roles"]
+
+        # Find test role
+        test_role = next((role for role in roles if role["RoleName"] == "test-inventory-role"), None)
+
+        assert test_role is not None, "Test role should be discovered"
+        assert test_role["Description"] == "Test role for inventory testing"
+
+    @mock_aws
+    def test_iam_policy_discovery(self):
+        """
+        Test IAM managed policy discovery patterns.
+        """
+        iam_client = boto3.client("iam", region_name="us-east-1")
+
+        # Create test policy
+        import json
+
+        policy_document = {
+            "Version": "2012-10-17",
+            "Statement": [{"Effect": "Allow", "Action": "s3:GetObject", "Resource": "arn:aws:s3:::test-bucket/*"}],
+        }
+
+        policy_response = iam_client.create_policy(
+            PolicyName="test-inventory-policy",
+            PolicyDocument=json.dumps(policy_document),
+            Description="Test policy for inventory testing",
+        )
+
+        policy_arn = policy_response["Policy"]["Arn"]
+
+        # Test policy discovery
+        policies_response = iam_client.list_policies(Scope="Local")
+        policies = policies_response["Policies"]
+
+        # Find test policy
+        test_policy = next((policy for policy in policies if policy["Arn"] == policy_arn), None)
+
+        assert test_policy is not None, "Test policy should be discovered"
+        assert test_policy["PolicyName"] == "test-inventory-policy"
+
+
+class TestArgumentParsingValidation:
+    """
+    Unit tests for CLI argument parsing validation.
+
+    These tests validate argument parsing logic without requiring AWS services.
+    """
+
+    def test_common_argument_patterns(self):
+        """
+        Test common argument parsing patterns used across inventory scripts.
+
+        This demonstrates testing CLI argument parsing in isolation.
+        """
+        # Test data for common argument patterns
+        test_cases = [
+            {
+                "args": ["--profile", "test-profile", "--verbose"],
+                "expected_profile": "test-profile",
+                "expected_verbose": True,
+            },
+            {
+                "args": ["--region", "us-west-2", "--output", "json"],
+                "expected_region": "us-west-2",
+                "expected_output": "json",
+            },
+        ]
+
+        # This would normally test actual argument parsing functions
+        # For now, demonstrates the testing pattern
+        for case in test_cases:
+            # Mock argument parsing would go here
+            assert isinstance(case["args"], list)
+            assert len(case["args"]) >= 2
+
+
+if __name__ == "__main__":
+    # Allow running individual test file
+    pytest.main([__file__, "-v"])

runbooks/inventory/tests/test_org_list_accounts.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+
+import pytest
+from botocore import client
+from common_test_data import cli_provided_parameters1, cli_provided_parameters2, get_all_my_orgs_test_result_dict
+from common_test_functions import AWSAccount_from_AWSKeyID, _amend_make_api_call, _amend_make_api_call_orig
+from org_list_accounts import all_my_orgs
+
+
+@pytest.mark.parametrize(
+    "parameters,test_value_dict",
+    [
+        (cli_provided_parameters1, get_all_my_orgs_test_result_dict),
+        (cli_provided_parameters2, get_all_my_orgs_test_result_dict),
+        # str(1993),
+        # json.dumps({"SecretString": "my-secret"}),
+        # json.dumps([2, 3, 5, 7, 11, 13, 17, 19]),
+        # KeyError("How dare you touch my secret!"),
+        # ValueError("Oh my goodness you even have the guts to repeat it!!!"),
+    ],
+)
+def test_get_account_data(parameters, test_value_dict, mocker):
+    pProfiles = parameters["pProfiles"]
+    pSkipProfiles = parameters["pSkipProfiles"]
+    pAccountList = parameters["pAccountList"]
+    pTiming = parameters["pTiming"]
+    pRootOnly = parameters["pRootOnly"]
+    pSaveFilename = parameters["pSaveFilename"]
+    pShortform = parameters["pShortform"]
+    pverbose = parameters["pverbose"]
+    test_data = {"FunctionName": "all_my_orgs", "AccountSpecific": True, "RegionSpecific": True}
+    # _amend_make_api_call_orig(pProfiles[0], test_value, mocker)
+    _amend_make_api_call(test_data, test_value_dict, mocker)
+
+    # if isinstance(test_value_dict, Exception):
+    # 	print("Expected Error...")
+    # 	with pytest.raises(type(test_value_dict)) as error:
+    # 		all_my_orgs(pProfiles, pSkipProfiles, pAccountList, pTiming, pRootOnly, pSaveFilename, pShortform, pverbose)
+    # 	result = error
+    # else:
+
+    # During the run of this test, the profile provided MUST match something real on the user's desktop,
+    # otherwise the script thinks the profile is unmatched and doesn't try to use it.
+    # In further testing, I'll have to figure out how to mock the session call, since it's not being caught by the "make_api_call" function...
+    result = all_my_orgs(
+        pProfiles, pSkipProfiles, pAccountList, pTiming, pRootOnly, pSaveFilename, pShortform, pverbose
+    )
+
+    print("Result:", result)

runbooks/inventory/update_aws_actions.py

@@ -0,0 +1,173 @@
+import logging
+import sys
+from datetime import datetime
+from os.path import split
+from queue import Queue
+from threading import Thread
+from time import time
+
+import boto3
+from ArgumentsClass import CommonArguments
+from colorama import Fore, Style, init
+from tqdm.auto import tqdm, trange
+
+__version__ = "2024.04.24"
+
+from tqdm import trange
+
+init()
+
+
+##################
+# Functions
+##################
+
+
+def parse_args(f_arguments):
+    """
+    Description: Parses the arguments passed into the script
+    @param f_arguments: args represents the list of arguments passed in
+    @return: returns an object namespace that contains the individualized parameters passed in
+    """
+    script_path, script_name = split(sys.argv[0])
+    parser = CommonArguments()
+    parser.my_parser.description = "We're going to find all API actions within the available AWS services."
+    parser.timing()
+    parser.save_to_file()
+    parser.verbosity()
+    parser.version(__version__)
+    local = parser.my_parser.add_argument_group(script_name, "Parameters specific to this script")
+    # local.add_argument(
+    # 	"-s", "--status",
+    # 	dest="pStatus",
+    # 	choices=['running', 'stopped'],
+    # 	type=str,
+    # 	default=None,
+    # 	help="Whether you want to limit the instances returned to either 'running', 'stopped'. Default is both")
+    return parser.my_parser.parse_args(f_arguments)
+
+
+def random_string(stringLength=10):
+    """
+    Description: Generates a random string
+    @param stringLength: to determine the length of the random number generated
+    @return: returns a random string of characters of length "stringlength"
+    """
+    import random
+    import string
+
+    # Generate a random string of fixed length
+    letters = string.ascii_lowercase
+    randomstring = "".join(random.choice(letters) for _ in range(stringLength))
+    return randomstring
+
+
+def get_aws_actions():
+    """
+    Description: Gets all the actions for all the services in AWS
+    @return: list of actions
+    """
+
+    class AWSActionThread(Thread):
+        def __init__(self, queue):
+            Thread.__init__(self)
+            self.queue = queue
+
+        def run(self):
+            while True:
+                # existing code to get actions for a service
+                c_service = self.queue.get()
+                client = boto3.client(c_service)
+                try:
+                    list_of_operations = client.meta.method_to_api_mapping.keys()
+                    # print(f"{ERASE_LINE}Checking actions for {c_service}", end='\r', flush=True)
+                    for operation in tqdm(list_of_operations, desc=f"actions for {c_service}", leave=False):
+                        action_list.append({"Service": c_service, "Operation": operation})
+                except AttributeError as myError:
+                    print(myError)
+                    action_list.append({"Service": c_service, "Operation": None})
+                    pass
+                finally:
+                    self.queue.task_done()
+
+    checkqueue = Queue()
+    action_list = []
+    workerthreads = 10
+
+    for x in trange(
+        workerthreads,
+        desc=f"Creating {workerthreads} worker threads",
+        leave=False,
+        # , position=0
+    ):
+        worker = AWSActionThread(checkqueue)
+        worker.daemon = True
+        worker.start()
+
+    # Create a thread for every service.
+    print(f"Capturing all available AWS Services...")
+    for service in tqdm(
+        list_of_services,
+        desc=f"Checking actions for each service",
+        # , position=0
+    ):
+        # for service in list_of_services:
+        checkqueue.put(service)
+        checkqueue.join()
+
+    return action_list
+
+
+def save_file(file_to_save_to: str = None, input_data: list = None):
+    """
+    Description: Saves the data to a file
+    @param file_to_save_to:
+    @param input_data:
+    @return: None
+    """
+    if input_data is None:
+        print(f"Input data cannot be none. Exiting...")
+        raise SystemExit(1)
+    elif len(input_data) == 0:
+        print(f"No data to save. Exiting...")
+        raise SystemExit(1)
+
+    if file_to_save_to is None:
+        print(f"No filename provided to save data.\nUsing a randomized name.")
+        file_to_save_to = random_string(15) + ".txt"
+    else:
+        logging.info(f"Saving data to {file_to_save_to}")
+    with open(file_to_save_to, "w", encoding="utf-8") as f:
+        for item in input_data:
+            f.write(f"{item['Service']}:{item['Operation']}\n")
+    return file_to_save_to
+
+
+##################
+# Main
+##################
+ERASE_LINE = "\x1b[2K"
+begin_time = time()
+
+if __name__ == "__main__":
+    arguments = parse_args(sys.argv[1:])
+    pTiming = arguments.Time
+    file_to_save = arguments.Filename
+    verbose = arguments.loglevel
+    logging.basicConfig(level=verbose, format="[%(filename)s:%(lineno)s - %(funcName)20s() ] %(message)s")
+    logging.getLogger("boto3").setLevel(logging.CRITICAL)
+    logging.getLogger("botocore").setLevel(logging.CRITICAL)
+    logging.getLogger("s3transfer").setLevel(logging.CRITICAL)
+    logging.getLogger("urllib3").setLevel(logging.CRITICAL)
+
+    list_of_services = boto3.Session().get_available_services()
+    all_actions = get_aws_actions()
+    if pTiming:
+        print(ERASE_LINE)
+        print(f"{Fore.GREEN}This script took {time() - begin_time:.2f} seconds{Fore.RESET}")
+    print(ERASE_LINE)
+    print(f"Found {len(all_actions)} actions across {len(list_of_services)} services")
+    filename = save_file(file_to_save, all_actions)
+    print(f"Saved to {filename}")
+    print("Thank you for using this script")
+    print()