"""Test rules."""
from constants import rule_error_codes
from ddex_ingester_common.constants.catalog_ingestion import (
    REJECT,
    SUCCESS,
    WARNING,
)
import rules


def test_require_product_name(s3_context):
    """Test requires product name rule."""
    output = rules.require_product_name(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_NAME, SUCCESS, None)


def test_require_product_name_invalid(s3_context):
    """Test requires product name rule."""
    s3_context['product']['product_name'] = ''
    output = rules.require_product_name(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_NAME,
        REJECT,
        'Product Name is missing'
    )


def test_require_product_release_reference(s3_context):
    """Test requires product release reference rule."""
    output = rules.require_product_release_reference(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_RELEASE_REFERENCE,
        SUCCESS,
        None
    )


def test_require_product_release_reference_invalid(s3_context):
    """Test requires product release reference rule."""
    s3_context['product']['release_reference'] = ''
    output = rules.require_product_release_reference(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_RELEASE_REFERENCE,
        REJECT,
        'Product Release Reference is missing'
    )


def test_require_product_display_artist_name(s3_context):
    """Test requires product display artist name rule."""
    output = rules.require_product_display_artist_name(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_DISPLAY_ARTIST_NAME,
        SUCCESS,
        None
    )


def test_require_product_display_artist_name_invalid(s3_context):
    """Test requires product display artist name rule."""
    s3_context['product']['display_artist_name'] = ''
    output = rules.require_product_display_artist_name(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_DISPLAY_ARTIST_NAME,
        REJECT,
        'Product Display Artist Name is missing'
    )


def test_require_product_release_type(s3_context):
    """Test requires product release type rule."""
    output = rules.require_product_release_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_RELEASE_TYPE,
        SUCCESS,
        None
    )


def test_require_product_release_type_invalid(s3_context):
    """Test requires product release type rule."""
    s3_context['product']['release_type'] = ''
    output = rules.require_product_release_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_RELEASE_TYPE,
        REJECT,
        'Product Release Type is missing'
    )


def test_require_product_is_main_release_true(s3_context):
    """Test requires product is main release rule."""
    s3_context['product']['is_main_release'] = True
    output = rules.require_product_is_main_release(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_IS_MAIN_RELEASE,
        SUCCESS,
        None
    )


def test_require_product_is_main_release_false(s3_context):
    """Test requires product is main release rule."""
    s3_context['product']['is_main_release'] = False
    output = rules.require_product_is_main_release(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_IS_MAIN_RELEASE,
        SUCCESS,
        None
    )


def test_require_product_is_main_release_invalid(s3_context):
    """Test requires product is main release rule."""
    s3_context['product']['is_main_release'] = None
    output = rules.require_product_is_main_release(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_IS_MAIN_RELEASE,
        REJECT,
        'Product Main Release is missing'
    )


def test_require_product_upc(s3_context):
    """Test requires product UPC rule."""
    output = rules.require_product_upc(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_UPC,
        SUCCESS,
        None
    )


def test_require_product_upc_invalid(s3_context):
    """Test requires product UPC rule."""
    s3_context['product']['upc'] = ''
    output = rules.require_product_upc(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT_UPC,
        REJECT,
        'Product UPC is missing'
    )


def test_require_party_id_awal_party_id(s3_context):
    """Test requires party id rule with AWAL party id."""
    s3_context['party_id'] = 'PADPIDA20100409010'
    output = rules.require_party_id(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_PARTY_ID, SUCCESS, None)


def test_require_party_id_empty_party_id(s3_context):
    """Test requires party id rule with empty party id."""
    party_id = ''
    s3_context['party_id'] = party_id
    output = rules.require_party_id(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_PARTY_ID,
        REJECT,
        'Party Id is missing'
    )


def test_require_party_id_unknown_party_id(s3_context):
    """Test requires party id rule with an unknown party id."""
    party_id = 'PADPIDA20100409019'
    s3_context['party_id'] = 'PADPIDA20100409019'
    output = rules.require_party_id(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_PARTY_ID,
        REJECT,
        f'Invalid Party Id: {party_id}'
    )


def test_require_message_id(s3_context):
    """Test requires message_id rule."""
    output = rules.require_message_id(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_MESSAGE_ID,
        SUCCESS,
        None
    )


def test_require_message_id_invalid(s3_context):
    """Test requires message id rule."""
    s3_context['message_id'] = ''
    output = rules.require_message_id(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_MESSAGE_ID,
        REJECT,
        'Message Id is missing'
    )


def test_require_product(s3_context):
    """Test requires product rule."""
    output = rules.require_product(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT,
        SUCCESS,
        None
    )


def test_require_product_invalid(s3_context):
    """Test requires product UPC rule."""
    s3_context['product'] = ''
    output = rules.require_product(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PRODUCT,
        REJECT,
        'Product is missing'
    )


def test_require_valid_awal_genre_missing_genre(
        s3_context, genres):
    """Test require_valid_awal_genre rule."""
    s3_context['product']['genres'] = None

    result = rules.require_valid_awal_genre(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_GENRE,
        REJECT,
        'Genre is missing'
    )


def test_require_valid_awal_genre_pass(
        s3_context, genres):
    """Test require_valid_awal_genre rule."""
    s3_context['product']['genres'] = [
        {
            'genre': 'Blues',
            'subgenre': 'Acoustic Blues'
        },
    ]

    result = rules.require_valid_awal_genre(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_GENRE, SUCCESS, None)


def test_require_valid_awal_genre_missing_subgenre(
        s3_context, genres):
    """Test require_valid_awal_genre rule."""
    s3_context['product']['genres'] = [
        {
            'genre': 'Blues',
        },
    ]

    result = rules.require_valid_awal_genre(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_SUBGENRE,
        REJECT,
        'Subgenre is missing'
    )


def test_require_valid_awal_genre_wrong_subgenre(
        s3_context, genres):
    """Test require_valid_awal_genre rule."""
    s3_context['product']['genres'] = [
        {
            'genre': 'Blues',
            'subgenre': 'Death Metal'
        },
    ]

    result = rules.require_valid_awal_genre(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.INVALID_SUBGENRE,
        REJECT,
        'Invalid subgenre for genre Blues'
    )


def test_require_valid_awal_genre_wrong_genre(
        s3_context, genres):
    """Test require_valid_awal_genre rule."""
    s3_context['product']['genres'] = [
        {
            'genre': 'genre',
            'subgenre': 'subgenre'
        },
    ]

    result = rules.require_valid_awal_genre(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.INVALID_GENRE,
        REJECT,
        'Invalid genre'
    )


def test_require_valid_cline(s3_context):
    """Test require_valid_cline."""
    result = rules.require_valid_cline(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.INVALID_CLINE, SUCCESS, None)


def test_require_valid_cline_missing(s3_context):
    """Test require_valid_cline missing."""
    s3_context['product']['c_line'] = None
    result = rules.require_valid_cline(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.INVALID_CLINE, SUCCESS, None)


def test_require_valid_cline_reject(s3_context):
    """Test require_valid_cline reject."""
    s3_context['product']['c_line'] = 'product c-line'
    result = rules.require_valid_cline(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.INVALID_CLINE,
        REJECT,
        'Invalid product C-Line'
    )


def test_require_valid_pline(s3_context):
    """Test require_valid_pline."""
    result = rules.require_valid_pline(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.INVALID_PLINE, SUCCESS, None)


def test_require_valid_pline_missing(s3_context):
    """Test require_valid_pline missing."""
    s3_context['tracks'][0]['p_line'] = None
    result = rules.require_valid_pline(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.INVALID_PLINE, SUCCESS, None)


def test_require_valid_pline_reject(s3_context):
    """Test require_valid_pline."""
    s3_context['tracks'][0]['p_line'] = 'track p-line'
    result = rules.require_valid_pline(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.INVALID_PLINE,
        REJECT,
        'Invalid P-Line on track 1-1'
    )


def test_validate_product_localization_language_codes(s3_context):
    """Test validate_product_localization_language_codes."""
    result = rules.validate_product_localization_language_codes(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.DUPLICATE_LOCALIZED_PRODUCT_LANGUAGE_CODE)


def test_validate_product_localization_language_codes_fail_chinese(s3_context):
    """Test validate_product_localization_language_codes fail chinese."""
    s3_context['product']['localized_titles'] = [
        {
            'language_code': 'cmn-Hans',
            'title': '标题',
            'sub_title': '副标题',
        },
        {
            'language_code': 'en',
            'title': 'title',
            'subtitle': 'subtitle',
        },
    ]
    result = rules.validate_product_localization_language_codes(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_CHINESE_SIMPLIFIED_OR_TRADITIONAL,
        WARNING,
        'Both Simplified and Traditional Chinese must be present for localized'
        ' product title'
    )


def test_validate_product_display_artist_language_codes(s3_context):
    """Test validate_product_display_artist_language_codes."""
    result = rules.validate_product_display_artist_language_codes(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.DUPLICATE_LOCALIZED_PRODUCT_ARTIST_LANGUAGE_CODE)


def test_validate_product_display_artist_language_codes_fail(s3_context):
    """Test validate_product_display_artist_language_codes."""
    s3_context['product']['display_artists'][1]['localized_names'].append(
        {
            'name': 'english name 2',
            'language_code': 'en'
        }
    )
    result = rules.validate_product_display_artist_language_codes(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.DUPLICATE_LOCALIZED_PRODUCT_ARTIST_LANGUAGE_CODE,
        REJECT,
        'Duplicate language code en not allowed for localization'
    )


def test_require_track_name(s3_context):
    """Test requires track name rule."""
    output = rules.require_track_name(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_NAME,
        SUCCESS,
        None
    )


def test_require_track_name_invalid(s3_context):
    """Test requires track name rule."""
    s3_context['tracks'][0]['track_name'] = ''
    output = rules.require_track_name(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_NAME,
        REJECT,
        'Track Name is missing'
    )


def test_require_track_isrc(s3_context):
    """Test requires track ISRC rule."""
    output = rules.require_track_isrc(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_ISRC,
        SUCCESS,
        None
    )


def test_require_track_isrc_invalid(s3_context):
    """Test requires track ISRC rule."""
    s3_context['tracks'][0]['isrc'] = ''
    output = rules.require_track_isrc(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_ISRC,
        REJECT,
        'Track ISRC is missing'
    )


def test_require_track_unique_isrc(s3_context):
    """Test requires track unique ISRC rule."""
    output = rules.require_track_unique_isrc(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.DUPLICATE_TRACK_ISRC,
        SUCCESS,
        None
    )


def test_require_track_unique_isrc_invalid(s3_context):
    """Test requires track unique ISRC rule."""
    s3_context['tracks'][1]['isrc'] = s3_context['tracks'][0]['isrc']
    output = rules.require_track_unique_isrc(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.DUPLICATE_TRACK_ISRC,
        REJECT,
        'Duplicate track ISRC QZCDB2000001'
    )


def test_require_track_sequence_number(s3_context):
    """Test requires track sequence number rule."""
    output = rules.require_track_sequence_number(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_SEQUENCE_NUMBER,
        SUCCESS,
        None
    )


def test_require_track_sequence_number_invalid(s3_context):
    """Test requires track sequence number rule."""
    s3_context['tracks'][0]['sequence_number'] = ''
    output = rules.require_track_sequence_number(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_SEQUENCE_NUMBER,
        REJECT,
        'Track Sequence Number is missing'
    )


def test_require_track_volume(s3_context):
    """Test requires track volume rule."""
    output = rules.require_track_volume(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_VOLUME,
        SUCCESS,
        None
    )


def test_require_track_volume_invalid(s3_context):
    """Test requires track volume rule."""
    s3_context['tracks'][0]['volume'] = ''
    output = rules.require_track_volume(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_VOLUME,
        REJECT,
        'Track Volume is missing'
    )


def test_require_track_release_type(s3_context):
    """Test requires track release type rule."""
    output = rules.require_track_release_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_RELEASE_TYPE,
        SUCCESS,
        None
    )


def test_require_track_release_type_invalid(s3_context):
    """Test requires track release type rule."""
    s3_context['tracks'][0]['release_type'] = ''
    output = rules.require_track_release_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_RELEASE_TYPE,
        REJECT,
        'Track Release Type is missing'
    )


def test_require_track_release_reference(s3_context):
    """Test requires track release reference rule."""
    output = rules.require_track_release_reference(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_RELEASE_REFERENCE,
        SUCCESS,
        None
    )


def test_require_track_release_reference_invalid(s3_context):
    """Test requires track release reference rule."""
    s3_context['tracks'][0]['release_reference'] = ''
    output = rules.require_track_release_reference(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_RELEASE_REFERENCE,
        REJECT,
        'Track Release Reference is missing'
    )


def test_require_track_resource_reference(s3_context):
    """Test requires track resource reference rule."""
    output = rules.require_track_resource_reference(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_RESOURCE_REFERENCE,
        SUCCESS,
        None
    )


def test_require_track_resource_reference_invalid(s3_context):
    """Test requires track resource reference rule."""
    s3_context['tracks'][0]['resource_reference'] = ''
    output = rules.require_track_resource_reference(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_TRACK_RESOURCE_REFERENCE,
        REJECT,
        'Track Resource Reference is missing'
    )


def test_validate_track_localization_language_codes(s3_context):
    """Test validate_track_localization_language_codes."""
    result = rules.validate_track_localization_language_codes(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.DUPLICATE_LOCALIZED_TRACK_LANGUAGE_CODE)


def test_validate_track_localization_language_codes_fail_chinese(s3_context):
    """Test validate_track_localization_language_codes fail chinese."""
    s3_context['tracks'][1]['localized_titles'] = [
        {
            'language_code': 'cmn-Hans',
            'title': '标题',
            'sub_title': '副标题',
        },
        {
            'language_code': 'en',
            'title': 'title',
            'subtitle': 'subtitle',
        },
    ]
    result = rules.validate_track_localization_language_codes(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_CHINESE_SIMPLIFIED_OR_TRADITIONAL,
        WARNING,
        'Both Simplified and Traditional Chinese must be present for '
        'This track 2'
    )


def test_validate_track_display_artist_language_codes(s3_context):
    """Test validate_track_display_artist_language_codes."""
    result = rules.validate_track_display_artist_language_codes(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.DUPLICATE_LOCALIZED_TRACK_ARTIST_LANGUAGE_CODE)


def test_validate_track_display_artist_language_codes_fail(s3_context):
    """Test validate_track_display_artist_language_codes fails."""
    s3_context['tracks'][1]['display_artists'][1]['localized_names'].append(
        {
            'name': 'english name 2',
            'language_code': 'en'
        }
    )
    result = rules.validate_track_display_artist_language_codes(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.DUPLICATE_LOCALIZED_TRACK_ARTIST_LANGUAGE_CODE,
        REJECT,
        'Duplicate language code en not allowed for localization'
    )


def test_require_orchard_label(s3_context):
    """Test require_orchard_label success."""
    result = rules.require_orchard_label(s3_context)

    assert result == rules.RuleResult(rule_error_codes.MISSING_ORCHARD_LABEL)


def test_require_orchard_label_missing(s3_context):
    """Test require_orchard_label failure."""
    del s3_context['product']['vendor_id']
    result = rules.require_orchard_label(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_ORCHARD_LABEL,
        REJECT,
        'Orchard Label ID is missing'
    )


def test_require_project_data(s3_context):
    """Test require_project_from_ext_meta."""
    result = rules.require_project_from_ext_meta(s3_context)

    assert result == rules.RuleResult(rule_error_codes.MISSING_PROJECT_DATA)


def test_require_project_data_missing(s3_context):
    """Test require_project_from_ext_meta missing project section."""
    s3_context['project'] = None
    result = rules.require_project_from_ext_meta(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_PROJECT_DATA,
        REJECT,
        'Project section is missing'
    )


def test_require_project_code_missing(s3_context):
    """Test require_project_from_ext_meta missing project code."""
    s3_context['project']['project_code'] = None
    result = rules.require_project_from_ext_meta(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_PROJECT_CODE,
        REJECT,
        'Project code is missing'
    )


def test_require_project_artist_missing(s3_context):
    """Test require_project_from_ext_meta missing project code."""
    s3_context['project']['artist'] = None
    result = rules.require_project_from_ext_meta(s3_context)

    assert result == rules.RuleResult(
        rule_error_codes.MISSING_PROJECT_ARTIST,
        REJECT,
        'Project artist is missing'
    )


def test_require_video_name(s3_context):
    """Test requires video name rule."""
    output = rules.require_video_name(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_NAME,
        SUCCESS,
        None
    )


def test_require_video_name_invalid(s3_context):
    """Test requires video name rule."""
    s3_context['video']['video_name'] = ''
    output = rules.require_video_name(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_NAME,
        REJECT,
        'Video Name is missing'
    )


def test_require_video_isrc(s3_context):
    """Test requires video ISRC rule."""
    output = rules.require_video_isrc(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_ISRC,
        SUCCESS,
        None
    )


def test_require_video_isrc_invalid(s3_context):
    """Test requires video ISRC rule."""
    s3_context['video']['isrc'] = ''
    output = rules.require_video_isrc(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_ISRC,
        REJECT,
        'Video ISRC is missing'
    )


def test_require_video_release_type(s3_context):
    """Test requires video release type rule."""
    output = rules.require_video_release_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_RELEASE_TYPE,
        SUCCESS,
        None
    )


def test_require_video_release_type_invalid(s3_context):
    """Test requires video release type rule."""
    s3_context['video']['release_type'] = ''
    output = rules.require_video_release_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_RELEASE_TYPE,
        REJECT,
        'Video Release Type is missing'
    )


def test_require_video_release_reference(s3_context):
    """Test requires video release reference rule."""
    output = rules.require_video_release_reference(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_RELEASE_REFERENCE,
        SUCCESS,
        None
    )


def test_require_video_release_reference_invalid(s3_context):
    """Test requires video release reference rule."""
    s3_context['video']['release_reference'] = ''
    output = rules.require_video_release_reference(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_RELEASE_REFERENCE,
        REJECT,
        'Video Release Reference is missing'
    )


def test_validate_video_p_line(s3_context):
    """Test validate video pline rule."""
    output = rules.validate_video_p_line(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_PLINE_DATA,
        SUCCESS,
        None
    )


def test_validate_video_p_line_invalid(s3_context):
    """Test validate video pline rule."""
    s3_context['video']['p_line'] = {'invalid': 'data'}
    output = rules.validate_video_p_line(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_PLINE_DATA,
        REJECT,
        'Video PLine Text is missing'
    )


def test_validate_video_c_line(s3_context):
    """Test validate video cline rule."""
    output = rules.validate_video_c_line(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_CLINE_DATA,
        SUCCESS,
        None
    )


def test_validate_video_c_line_invalid(s3_context):
    """Test validate video cline rule."""
    s3_context['video']['c_line'] = {'invalid': 'data'}
    output = rules.validate_video_c_line(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_VIDEO_CLINE_DATA,
        REJECT,
        'Video CLine Text is missing'
    )


def test_validate_product_participants(s3_context):
    """Test validate product participants rule."""
    output = rules.validate_product_participants(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PARTICIPANT_DATA,
        SUCCESS,
        None
    )


def test_validate_product_participants_invalid(s3_context):
    """Test validate product participants rule."""
    s3_context['product']['display_artists'].append({'invalid': 'data'})
    output = rules.validate_product_participants(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PARTICIPANT_DATA,
        REJECT,
        'Product Participant Name is missing'
    )


def test_validate_track_participants(s3_context):
    """Test validate track participants rule."""
    output = rules.validate_track_participants(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PARTICIPANT_DATA,
        SUCCESS,
        None
    )


def test_validate_track_participants_invalid(s3_context):
    """Test validate track participants rule."""
    s3_context['tracks'][0]['display_artists'].append({'invalid': 'data'})
    output = rules.validate_track_participants(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PARTICIPANT_DATA,
        REJECT,
        'Track Participant Name is missing'
    )


def test_validate_video_participants(s3_context):
    """Test validate video participants rule."""
    output = rules.validate_video_participants(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PARTICIPANT_DATA,
        SUCCESS,
        None
    )


def test_validate_video_participants_invalid(s3_context):
    """Test validate video participants rule."""
    s3_context['video']['display_artists'].append({'invalid': 'data'})
    output = rules.validate_video_participants(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_PARTICIPANT_DATA,
        REJECT,
        'Video Participant Name is missing'
    )


def test_validate_product_localized_titles(s3_context):
    """Test validate product localized titles rule."""
    output = rules.validate_product_localized_titles(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_LOCALIZED_TITLE_DATA,
        SUCCESS,
        None
    )


def test_validate_product_localized_titles_invalid(s3_context):
    """Test validate product localized titles rule."""
    s3_context['product']['localized_titles'].append({'invalid': 'data'})
    output = rules.validate_product_localized_titles(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_LOCALIZED_TITLE_DATA,
        REJECT,
        'Product Localization Title is missing'
    )


def test_validate_track_localized_titles(s3_context):
    """Test validate track localized titles rule."""
    output = rules.validate_track_localized_titles(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_LOCALIZED_TITLE_DATA,
        SUCCESS,
        None
    )


def test_validate_track_localized_titles_invalid(s3_context):
    """Test validate track localized titles rule."""
    s3_context['tracks'][0]['localized_titles'].append({'invalid': 'data'})
    output = rules.validate_track_localized_titles(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_LOCALIZED_TITLE_DATA,
        REJECT,
        'Track Localization Title is missing'
    )


def test_validate_product_localized_artists(s3_context):
    """Test validate product localized artists rule."""
    output = rules.validate_product_localized_artists(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_LOCALIZED_ARTIST_DATA,
        SUCCESS,
        None
    )


def test_validate_product_localized_artists_invalid(s3_context):
    """Test validate product localized artists rule."""
    s3_context['product']['display_artists'][0]['localized_names'].append(
        {'invalid': 'data'})
    output = rules.validate_product_localized_artists(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_LOCALIZED_ARTIST_DATA,
        REJECT,
        'Product Artist Localization Name is missing'
    )


def test_validate_track_localized_artists(s3_context):
    """Test validate track localized artists rule."""
    output = rules.validate_track_localized_artists(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_LOCALIZED_ARTIST_DATA,
        SUCCESS,
        None
    )


def test_validate_track_localized_artists_invalid(s3_context):
    """Test validate track localized artists rule."""
    s3_context['tracks'][0]['display_artists'][0]['localized_names'].append(
        {'invalid': 'data'})
    output = rules.validate_track_localized_artists(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_LOCALIZED_ARTIST_DATA,
        REJECT,
        'Track Artist Localization Name is missing'
    )


def test_validate_deal_release_references(s3_context):
    """Test validate deal release references rule."""
    output = rules.validate_deal_release_references(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_RELEASE_REFERENCES,
        SUCCESS,
        None
    )


def test_validate_deal_release_references_invalid(s3_context):
    """Test validate deal release references rule."""
    s3_context['deals'][0]['release_references'] = []
    output = rules.validate_deal_release_references(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_RELEASE_REFERENCES,
        REJECT,
        'Deal Release References are missing'
    )


def test_validate_deal_terms(s3_context):
    """Test validate deal terms rule."""
    output = rules.validate_deal_terms(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_TERMS,
        SUCCESS,
        None
    )


def test_validate_deal_terms_invalid(s3_context):
    """Test validate deal terms rule."""
    s3_context['deals'][0]['deal_terms'] = []
    output = rules.validate_deal_terms(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_TERMS,
        REJECT,
        'Deal Terms are missing'
    )


def test_validate_deal_term_commercial_model_types(s3_context):
    """Test validate deal term commercial model types rule."""
    output = rules.validate_deal_term_commercial_model_types(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_TERM_COMMERCIAL_MODEL_TYPES,
        SUCCESS,
        None
    )


def test_validate_deal_term_commercial_model_types_invalid(s3_context):
    """Test validate deal term commercial model types rule."""
    s3_context['deals'][0]['deal_terms'][0]['commercial_model_types'] = []
    output = rules.validate_deal_term_commercial_model_types(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_TERM_COMMERCIAL_MODEL_TYPES,
        REJECT,
        'Deal Term Commercial Model Types are missing'
    )


def test_validate_deal_term_usage_type(s3_context):
    """Test validate deal term usage type rule."""
    output = rules.validate_deal_term_usage_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_TERM_USAGE_TYPE,
        SUCCESS,
        None
    )


def test_validate_deal_term_usage_type_invalid(s3_context):
    """Test validate deal term usage type rule."""
    s3_context['deals'][0]['deal_terms'][0]['usage_type'] = []
    output = rules.validate_deal_term_usage_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_TERM_USAGE_TYPE,
        REJECT,
        'Deal Term Usage Type is missing'
    )


def test_validate_deal_term_territories(s3_context):
    """Test validate deal term territories rule."""
    output = rules.validate_deal_term_territories(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_TERM_TERRITORIES,
        SUCCESS,
        None
    )


def test_validate_deal_term_territories_invalid(s3_context):
    """Test validate deal term territories rule."""
    s3_context['deals'][0]['deal_terms'][0]['territories'] = []
    output = rules.validate_deal_term_territories(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_DEAL_TERM_TERRITORIES,
        REJECT,
        'Deal Term Territories are missing'
    )


def test_validate_instant_gratification_references(s3_context):
    """Test validate instant gratification references rule."""
    output = rules.validate_instant_gratification_references(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_INSTANT_GRATIFICATION_REFERENCES,
        SUCCESS,
        None
    )


def test_validate_instant_gratification_references_invalid(s3_context):
    """Test validate instant gratification references rule."""
    s3_context['deals'][0]['deal_terms'][0]['instant_gratifications'] = \
        {'invalid': 'data'}
    output = rules.validate_instant_gratification_references(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.MISSING_INSTANT_GRATIFICATION_REFERENCES,
        REJECT,
        'Instant Gratification References are missing'
    )


def test_validate_update_indicator(s3_context):
    """Test validate update indicator rule."""
    output = rules.validate_update_indicator(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_UPDATE_INDICATOR,
        SUCCESS,
        None
    )


def test_validate_update_indicator_invalid(s3_context):
    """Test validate update indicator rule."""
    s3_context['update_indicator'] = 'Not valid'
    output = rules.validate_update_indicator(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_UPDATE_INDICATOR,
        REJECT,
        'Invalid value for update indicator'
    )


def test_validate_product_price_type(
        s3_context,
        pricing_family_response):
    """Test validate product album price type rule."""
    s3_context['deals'][0]['deal_terms'][0]['price_type'] = '24'

    output = rules.validate_product_price_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_PRODUCT_PRICE_TYPE,
        SUCCESS,
        None
    )


def test_validate_product_price_type_invalid_1(
        s3_context,
        pricing_family_response):
    """Test validate product album price type rule."""
    s3_context['deals'][0]['deal_terms'][0]['price_type'] = 'Not valid'

    output = rules.validate_product_price_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_PRODUCT_PRICE_TYPE,
        REJECT,
        'Product price type "Not valid" is not an integer'
    )


def test_validate_product_price_type_invalid_2(
        s3_context,
        pricing_family_response):
    """Test validate product album price type rule."""
    s3_context['deals'][0]['deal_terms'][0]['price_type'] = '1'

    output = rules.validate_product_price_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_PRODUCT_PRICE_TYPE,
        REJECT,
        'Product price type "1" is not valid'
    )


def test_validate_product_price_type_null(
        s3_context,
        pricing_family_response):
    """Test validate product album price type rule."""
    s3_context['deals'][0]['deal_terms'][0]['price_type'] = None

    output = rules.validate_product_price_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_PRODUCT_PRICE_TYPE,
        SUCCESS,
        None
    )


def test_validate_track_price_type(
        s3_context,
        pricing_family_response):
    """Test validate product track price type rule."""
    s3_context['deals'][0]['deal_terms'][0]['price_type'] = '25'

    output = rules.validate_track_price_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_TRACK_PRICE_TYPE,
        SUCCESS,
        None
    )


def test_validate_track_price_type_invalid_1(
        s3_context,
        pricing_family_response):
    """Test validate product track price type rule."""
    s3_context['deals'][0]['deal_terms'][0]['price_type'] = 'Not Valid'

    output = rules.validate_track_price_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_TRACK_PRICE_TYPE,
        REJECT,
        'On track QZCDB2000001 price type "Not Valid" is not an integer'
    )


def test_validate_track_price_type_invalid_2(
        s3_context,
        pricing_family_response):
    """Test validate product track price type rule."""
    s3_context['deals'][0]['deal_terms'][0]['price_type'] = '1'

    output = rules.validate_track_price_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_TRACK_PRICE_TYPE,
        REJECT,
        'On track QZCDB2000001 price type "1" is not valid'
    )


def test_validate_track_price_type_null(
        s3_context,
        pricing_family_response):
    """Test validate product track price type rule."""
    s3_context['deals'][0]['deal_terms'][0]['price_type'] = None

    output = rules.validate_track_price_type(s3_context)
    assert output == rules.RuleResult(
        rule_error_codes.INVALID_TRACK_PRICE_TYPE,
        SUCCESS,
        None
    )