🗓️ Day 20: Python Set Operations

# Creating sets
empty_set = set()  # Note: {} creates a dict, not a set
numbers = {1, 2, 3, 4, 5}
languages = {"Python", "Java", "JavaScript", "Python"}  # Duplicate removed
print(languages)  # Output: {'Python', 'Java', 'JavaScript'}

# From other iterables
list_to_set = set([1, 2, 2, 3, 3, 4])
print(list_to_set)  # Output: {1, 2, 3, 4}

# Subset and Superset checks
required_permissions = {"read", "write"}
user_permissions = {"read", "write", "execute", "delete"}

# Check if user has all required permissions
has_all_required = required_permissions.issubset(user_permissions)
print(f"Has all required permissions: {has_all_required}")  # True

# Check if user has more than required
has_more = user_permissions.issuperset(required_permissions)
print(f"Has more than required: {has_more}")  # True

# Check if sets are disjoint (no common elements)
admin_actions = {"create_user", "delete_user"}
guest_actions = {"view_profile", "edit_profile"}
are_disjoint = admin_actions.isdisjoint(guest_actions)
print(f"No common actions: {are_disjoint}")  # True

class TestSuiteComparator:
    def __init__(self):
        self.comparison_results = {}
    
    def compare_suites(self, suite_a, suite_b, suite_a_name="Suite A", suite_b_name="Suite B"):
        set_a = set(suite_a)
        set_b = set(suite_b)
        
        # All operations in one analysis
        union = set_a | set_b  # All unique tests
        intersection = set_a & set_b  # Common tests
        only_in_a = set_a - set_b  # Tests only in suite A
        only_in_b = set_b - set_a  # Tests only in suite B
        symmetric_diff = set_a ^ set_b  # Tests in either but not both
        
        self.comparison_results = {
            'total_unique_tests': len(union),
            'common_tests': len(intersection),
            'common_test_list': intersection,
            f'only_in_{suite_a_name.lower().replace(" ", "_")}': only_in_a,
            f'only_in_{suite_b_name.lower().replace(" ", "_")}': only_in_b,
            'different_tests': symmetric_diff,
            'similarity_percentage': (len(intersection) / len(union)) * 100 if union else 0
        }
        
        return self.comparison_results
    
    def generate_report(self):
        if not self.comparison_results:
            return "No comparison data available"
        
        report = []
        report.append("=" * 50)
        report.append("TEST SUITE COMPARISON REPORT")
        report.append("=" * 50)
        report.append(f"Total unique tests across both suites: {self.comparison_results['total_unique_tests']}")
        report.append(f"Common tests: {self.comparison_results['common_tests']}")
        report.append(f"Similarity: {self.comparison_results['similarity_percentage']:.1f}%")
        report.append("")
        
        for key, value in self.comparison_results.items():
            if key.startswith('only_in_') and value:
                suite_name = key.replace('only_in_', '').replace('_', ' ').title()
                report.append(f"Tests only in {suite_name}: {value}")
        
        return "\n".join(report)

# Example usage
regression_tests = [
    "test_user_login", "test_user_logout", "test_password_reset",
    "test_profile_update", "test_data_export"
]

smoke_tests = [
    "test_user_login", "test_basic_navigation", "test_home_page_load",
    "test_user_logout"
]

comparator = TestSuiteComparator()
results = comparator.compare_suites(regression_tests, smoke_tests, "Regression", "Smoke")
print(comparator.generate_report())

class TestExecutionMonitor:
    def __init__(self, expected_tests):
        self.expected_tests = set(expected_tests)
        self.started_tests = set()
        self.completed_tests = set()
        self.failed_tests = set()
        self.skipped_tests = set()
    
    def start_test(self, test_name):
        if test_name in self.expected_tests:
            self.started_tests.add(test_name)
            print(f"🚀 Started: {test_name}")
        else:
            print(f"⚠️ Unexpected test started: {test_name}")
    
    def complete_test(self, test_name, status="passed"):
        if test_name in self.started_tests:
            self.completed_tests.add(test_name)
            if status == "failed":
                self.failed_tests.add(test_name)
            print(f"✅ Completed: {test_name} - {status}")
        else:
            print(f"❌ Test completed without being started: {test_name}")
    
    def skip_test(self, test_name):
        self.skipped_tests.add(test_name)
        print(f"⏭️ Skipped: {test_name}")
    
    def get_status_report(self):
        not_started = self.expected_tests - self.started_tests - self.skipped_tests
        in_progress = self.started_tests - self.completed_tests
        passed_tests = self.completed_tests - self.failed_tests
        
        return {
            'total_expected': len(self.expected_tests),
            'not_started': not_started,
            'in_progress': in_progress,
            'completed': len(self.completed_tests),
            'passed': len(passed_tests),
            'failed': len(self.failed_tests),
            'skipped': len(self.skipped_tests),
            'completion_rate': (len(self.completed_tests) / len(self.expected_tests)) * 100
        }

# Example usage
expected_tests = [
    "test_login", "test_navigation", "test_search", 
    "test_purchase", "test_logout"
]

monitor = TestExecutionMonitor(expected_tests)

# Simulate test execution
monitor.start_test("test_login")
monitor.complete_test("test_login", "passed")
monitor.start_test("test_navigation")
monitor.complete_test("test_navigation", "passed")
monitor.skip_test("test_search")
monitor.start_test("test_purchase")
monitor.complete_test("test_purchase", "failed")

# Get status report
status = monitor.get_status_report()
print(f"\n📊 Execution Status:")
print(f"Completion Rate: {status['completion_rate']:.1f}%")
print(f"Not Started: {status['not_started']}")
print(f"In Progress: {status['in_progress']}")
print(f"Failed: {status['failed']}")
print(f"Skipped: {status['skipped']}")