Client and Connection Management

class MongoClient:
    def __init__(self, host=None, port=None, document_class=dict, 
                 tz_aware=False, connect=True, _store=None, 
                 read_preference=None, **kwargs):
        """
        Create a mock MongoDB client.

        Parameters:
        - host: str or list, MongoDB server host(s) (ignored in mock)
        - port: int, MongoDB server port (ignored in mock)
        - document_class: type, class for documents (default: dict)
        - tz_aware: bool, timezone-aware datetime handling
        - connect: bool, immediate connection attempt (ignored in mock)
        - read_preference: ReadPreference, read preference setting
        - **kwargs: additional connection parameters

        Returns:
        MongoClient instance
        """

import mongomock

# Basic client
client = mongomock.MongoClient()

# Client with custom configuration
client = mongomock.MongoClient(
    host='localhost',
    port=27017,
    tz_aware=True,
    document_class=dict
)

# Client with connection string (parsed but ignored)
client = mongomock.MongoClient('mongodb://localhost:27017/testdb')

def get_database(self, name=None, codec_options=None, 
                read_preference=None, write_concern=None, 
                read_concern=None):
    """
    Get a database instance.

    Parameters:
    - name: str, database name (optional if default set)
    - codec_options: CodecOptions, encoding/decoding options
    - read_preference: ReadPreference, read preference override
    - write_concern: WriteConcern, write concern override
    - read_concern: ReadConcern, read concern override

    Returns:
    Database instance
    """

def get_default_database(self, default=None, **kwargs):
    """
    Get the default database.

    Parameters:
    - default: str, default database name if none configured
    - **kwargs: additional database options

    Returns:
    Database instance

    Raises:
    ConfigurationError: if no default database configured
    """

def list_database_names(self):
    """
    List all database names.

    Returns:
    List[str]: list of database names
    """

client = mongomock.MongoClient()

# Get database by name
db = client.get_database('testdb')
db = client['testdb']  # Alternative syntax
db = client.testdb     # Alternative syntax

# Get default database (if configured)
db = client.get_default_database()

# List all databases
databases = client.list_database_names()

def drop_database(self, name_or_db):
    """
    Drop a database.

    Parameters:
    - name_or_db: str or Database, database name or instance

    Returns:
    None
    """

client = mongomock.MongoClient()

# Create and populate database
db = client.testdb
db.collection.insert_one({'test': 'data'})

# Drop database
client.drop_database('testdb')
# or
client.drop_database(db)

def server_info(self):
    """
    Get server information.

    Returns:
    Dict[str, Any]: server information dictionary
    """

def alive(self):
    """
    Check if client connection is alive.

    Returns:
    bool: always True for mock client
    """

def close(self):
    """
    Close client connection.

    Returns:
    None
    """

def start_session(self, causal_consistency=True, default_transaction_options=None):
    """
    Start a client session (raises NotImplementedError).

    Parameters:
    - causal_consistency: bool, enable causal consistency
    - default_transaction_options: TransactionOptions, default transaction options

    Returns:
    ClientSession: session object

    Raises:
    NotImplementedError: sessions not implemented in mongomock
    """

client = mongomock.MongoClient()

# Get server information
info = client.server_info()
print(info['version'])  # Mock server version

# Check connection status
is_alive = client.alive()  # Always True

# Close connection
client.close()

@property
def host(self):
    """str: server host"""

@property  
def port(self):
    """int: server port"""

@property
def address(self):
    """tuple: (host, port) address tuple"""

@property
def read_preference(self):
    """ReadPreference: current read preference"""

@property
def codec_options(self):
    """CodecOptions: current codec options"""

@property
def is_mongos(self):
    """bool: whether connected to mongos (always True)"""

@property
def is_primary(self):
    """bool: whether connected to primary (always True)"""

client = mongomock.MongoClient('localhost', 27017)

print(f"Connected to {client.host}:{client.port}")
print(f"Address: {client.address}")
print(f"Is primary: {client.is_primary}")
print(f"Read preference: {client.read_preference}")

HOST = 'localhost'  # Default host
PORT = 27017       # Default port