Esempio n. 1
0
def test_attr_encrypt(topology_st, create_backend):
    """Test adding/removing encrypted attrs

    :id: 887429d5-b9be-4e48-b8ca-691e7437abca
    :setup: Standalone instance
    :steps:
        1. Add encrypted attr
        2. Verify it succeeded
        3. Delete encrypted attr
        4. Verity it was removed
    :expectedresults:
        1. Success
        2. Success
        3. Success
        4. Success

    """
    sys.stdout = io.StringIO()
    args = FakeArgs()
    args.cn = BE_NAME
    args.be_name = BE_NAME
    args.suffix = False
    args.nsslapd_suffix = SUFFIX
    args.json = False
    args.just_names = False
    args.list = False
    args.add_attr = None
    args.del_attr = None

    # Add an encrytped attr
    args.add_attr = ['description']
    backend_attr_encrypt(topology_st.standalone, None, None, args)
    args.add_attr = None
    check_output("added encrypted attribute")

    # Verify it worked
    args.list = True
    backend_attr_encrypt(topology_st.standalone, None, None, args)
    args.list = False
    check_output("cn: description")

    # Delete encrypted attr
    args.del_attr = ['description']
    backend_attr_encrypt(topology_st.standalone, None, None, args)
    args.del_attr = None
    check_output("deleted encrypted attribute")

    # Verify it worked
    args.list = True
    backend_attr_encrypt(topology_st.standalone, None, None, args)
    args.list = False
    check_output("cn: description", missing=True)
Esempio n. 2
0
    def fin():
        sys.stdout = io.StringIO()
        args = FakeArgs()
        args.cn = BE_NAME
        args.be_name = BE_NAME
        args.suffix = SUFFIX
        args.skip_subsuffixes = False
        args.json = False

        # Delete backend
        backend_delete(topology_st.standalone, None, None, args, warn=False)
        check_output("successfully deleted")

        # Verify it's removed
        args.suffix = False
        backend_list(topology_st.standalone, None, None, args)
        check_output("backendroot", missing=True)
Esempio n. 3
0
def test_import_export(topology_st):
    BE_NAME = 'userRoot'
    EXCLUDE_SUFFIX = "ou=Groups,dc=example,dc=com"
    LDIF_NAME = "test_import_export.ldif"
    LDIF_PATH = os.path.join(topology_st.standalone.ds_paths.ldif_dir,
                             LDIF_NAME)
    topology_st.logcap = LogCapture()
    args = FakeArgs()

    # Export the backend
    args.be_names = [BE_NAME]
    args.ldif = LDIF_NAME
    args.use_id2entry = None
    args.encrypted = None
    args.min_base64 = None
    args.no_dump_uniq_id = None
    args.replication = None
    args.not_folded = None
    args.no_seq_num = None
    args.include_suffixes = None
    args.exclude_suffixes = [EXCLUDE_SUFFIX]
    backend_export(topology_st.standalone, None, topology_st.logcap.log, args)

    # Verify export worked
    assert os.path.exists(LDIF_PATH)
    with open(LDIF_PATH, 'r') as ldif:
        for line in ldif:
            assert not line.endswith("%s\n" % EXCLUDE_SUFFIX)

    # Import the backend
    args.be_name = BE_NAME
    args.ldifs = [LDIF_NAME]
    args.chunks_size = None
    args.encrypted = None
    args.gen_uniq_id = None
    args.only_core = None
    args.include_suffixes = None
    args.exclude_suffixes = None
    backend_import(topology_st.standalone, None, topology_st.logcap.log, args)
    os.remove(LDIF_PATH)
Esempio n. 4
0
def create_backend(topology_st, request):
    """Create backend "dc=backend,dc=test" / backendRoot
    """
    sys.stdout = io.StringIO()

    args = FakeArgs()
    args.cn = BE_NAME
    args.be_name = BE_NAME
    args.suffix = False
    args.nsslapd_suffix = SUFFIX
    args.skip_subsuffixes = False
    args.json = False
    args.parent_suffix = False
    args.create_entries = True

    args.suffix = SUFFIX
    backend_create(topology_st.standalone, None, None, args)
    check_output("The database was successfully created")

    def fin():
        sys.stdout = io.StringIO()
        args = FakeArgs()
        args.cn = BE_NAME
        args.be_name = BE_NAME
        args.suffix = SUFFIX
        args.skip_subsuffixes = False
        args.json = False

        # Delete backend
        backend_delete(topology_st.standalone, None, None, args, warn=False)
        check_output("successfully deleted")

        # Verify it's removed
        args.suffix = False
        backend_list(topology_st.standalone, None, None, args)
        check_output("backendroot", missing=True)

    request.addfinalizer(fin)
Esempio n. 5
0
def test_import_warning(topology_st):
    """Import ldif file with skipped entries to generate a warning message

    :id: 66f9275b-11b4-4718-b401-18fa6011b362
    :setup: Standalone Instance
    :steps:
        1. Create LDIF file with skipped entries
        2. Import the LDIF file with backend import
        3. Check the topology logs
        4. Check errors log
    :expectedresults:
        1. Success
        2. Success
        3. Result message should contain warning code
        4. Errors log should contain skipped entry message
    """

    standalone = topology_st.standalone
    message = 'The import task has finished successfully, with warning code 8, check the logs for more detail'

    args = FakeArgs()
    args.be_name = 'userRoot'
    args.ldifs = [create_example_ldif(topology_st)]
    args.chunks_size = None
    args.encrypted = False
    args.gen_uniq_id = None
    args.only_core = False
    args.include_suffixes = 'dc=example,dc=com'
    args.exclude_suffixes = None

    log.info('Import the LDIF file')
    backend_import(standalone, DEFAULT_SUFFIX, topology_st.logcap.log, args)

    log.info('Check logs for a warning message')
    assert topology_st.logcap.contains(message)
    assert standalone.ds_error_log.match(
        '.*Skipping entry "uid=demo,ou=People,dc=example,dc=com" which has no parent.*'
    )
Esempio n. 6
0
def test_backend_cli(topology_st, create_backend):
    """Test creating, listing, getting, and deleting a backend (and subsuffix)
    :id: 800f432a-52ab-4661-ac66-a2bdd9b984d7
    :setup: Standalone instance
    :steps:
        1. List backends
        2. Get backend by suffix
        3. Get backend by DN
        4. Add subsuffix
        5. Verify subsuffix
        6. Modify subsuffix
        7. Delete subsuffix
        8. Verify subsuffix is removed
        9. Modify backend
        10. Verify modify worked
        11. Test monitor works
    :expectedresults:
        1. Success
        2. Success
        3. Success
        4. Success
        5. Success
        6. Success
        7. Success
        8. Success
        9. Success
        10. Success
        11. Success
    """
    topology_st.logcap = LogCapture()
    sys.stdout = io.StringIO()

    args = FakeArgs()
    args.cn = BE_NAME
    args.be_name = BE_NAME
    args.suffix = False
    args.nsslapd_suffix = SUFFIX
    args.skip_subsuffixes = False
    args.json = False
    args.parent_suffix = False
    args.create_entries = True

    # List backend
    backend_list(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output(SUFFIX)

    # Get backend by by name
    args.selector = BE_NAME
    backend_get(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output(BE_NAME)

    # Get backend by DN
    args.dn = 'cn=backendRoot,cn=ldbm database,cn=plugins,cn=config'
    backend_get_dn(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output(BE_NAME)

    # Add subsuffix
    args.parent_suffix = SUFFIX
    args.suffix = SUB_SUFFIX
    args.be_name = SUB_BE_NAME
    backend_create(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output("The database was successfully created")

    # Verify subsuffix
    args.suffix = False
    backend_list(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output(SUB_SUFFIX)

    # Modify subsuffix
    args.enable = False
    args.disable = False
    args.add_referral = False
    args.del_referral = False
    args.cache_size = False
    args.cache_memsize = False
    args.dncache_memsize = False
    args.enable_readonly = True  # Setting nsslapd-readonly to "on"
    args.disable_readonly = False
    backend_set(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output("successfully updated")

    # Verify modified worked
    args.selector = SUB_BE_NAME
    backend_get(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output("nsslapd-readonly: on")

    # Delete subsuffix
    args.suffix = SUB_SUFFIX
    backend_delete(topology_st.standalone,
                   None,
                   topology_st.logcap.log,
                   args,
                   warn=False)
    check_output("successfully deleted")

    # Verify it is deleted
    args.suffix = False
    backend_list(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output(SUB_BE_NAME, missing=True)

    # Modify backend (use same args from subsuffix modify)
    args.be_name = BE_NAME
    backend_set(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output("successfully updated")

    # Verify modified worked
    args.selector = BE_NAME
    backend_get(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output("nsslapd-readonly: on")

    # Run database monitor
    args.suffix = SUFFIX
    get_monitor(topology_st.standalone, None, topology_st.logcap.log, args)
    check_output("entrycachetries")
Esempio n. 7
0
def test_vlv(topology_st, create_backend):
    """Test creating, listing, getting, and deleting vlv's
    :id: 800f432a-52ab-4661-ac66-a2bdd9b984d790
    :setup: Standalone instance
    :steps:
        1. Add VLV search and index entries
        2. Verify they are created
        3. Edit VLV search and verify change
        4. Create additional VLV indexes
        5. Verity new indedxes were created
        6. Remove VLV indexes
        7. Verify indexes were removed
        8. Reindex VLV
    :expectedresults:
        1. Success
        2. Success
        3. Success
        4. Success
        5. Success
        6. Success
        7. Success
        8. Success

    """
    sys.stdout = io.StringIO()
    args = FakeArgs()
    args.cn = BE_NAME
    args.be_name = BE_NAME
    args.suffix = False
    args.nsslapd_suffix = SUFFIX
    args.json = False
    args.name = "myVLVSearch"
    args.index_name = "myVLVIndex"
    args.search_base = SUFFIX
    args.search_scope = '2'
    args.search_filter = "cn=*"
    args.parent_name = args.name
    args.index = False
    args.reindex = False
    args.sort = "cn sn"
    args.just_names = False

    # Create vlv search
    backend_create_vlv(topology_st.standalone, None, None, args)
    check_output("created new VLV Search entry")

    # Verify search is present
    backend_get_vlv(topology_st.standalone, None, None, args)
    check_output("VLV Search:")

    # Create VLV index under vlvSearch
    backend_create_vlv_index(topology_st.standalone, None, None, args)
    check_output("created new VLV index entry")

    # Verify index is present
    backend_get_vlv(topology_st.standalone, None, None, args)
    check_output("VLV Index:")

    # Edit VLV Search
    args.search_base = None
    args.search_scope = '0'
    args.search_filter = None
    args.sort = None
    backend_edit_vlv(topology_st.standalone, None, None, args)
    check_output("updated VLV search entry")

    # Verify edit was successful
    backend_get_vlv(topology_st.standalone, None, None, args)
    check_output("vlvscope: 0")

    # List vlv searches
    backend_list_vlv(topology_st.standalone, None, None, args)
    check_output("vlvbase: " + SUFFIX)

    # Add another index
    args.index_name = "my2ndVLVIndex"
    args.sort = "uid givenname"
    backend_create_vlv_index(topology_st.standalone, None, None, args)
    check_output("created new VLV index entry")

    # Verify new index was created
    backend_get_vlv(topology_st.standalone, None, None, args)
    check_output("vlvsort: uid givenname")

    # Reindex VLV
    backend_reindex_vlv(topology_st.standalone, None, None, args)
    check_output("reindexed VLV indexes")
    time.sleep(2)

    # Delete VLV search and indexes
    backend_del_vlv(topology_st.standalone, None, None, args)
    check_output("deleted VLV search and its indexes")

    # List vlv searches/indexes
    backend_list_vlv(topology_st.standalone, None, None, args)
    check_output("")
Esempio n. 8
0
def test_indexes(topology_st, create_backend):
    """Test creating, listing, getting, and deleting an index
    :id: 800f432a-52ab-4661-ac66-a2bdd9b984d78
    :setup: Standalone instance
    :steps:
        1. Add index (description)
        2. Verify index was added
        3. Modify index (Add type)
        4. Verify index was modified
        5. Modify index (Delete type)
        6. Verify index was modified
        7. Modify index (Add MR)
        8. Verify index was modified
        9. Modify index (Delete MR)
        10. Verify index was modified
        11. Reindex index
        12. Remove index
        13. Verify index was removed

    :expectedresults:
        1. Success
        2. Success
        3. Success
        4. Success
        5. Success
        6. Success
        7. Success
        8. Success
        9. Success
        10. Success
        11. Success
        12. Success
        13. Success
    """
    sys.stdout = io.StringIO()

    args = FakeArgs()
    args.cn = BE_NAME
    args.be_name = BE_NAME
    args.suffix = False
    args.nsslapd_suffix = SUFFIX
    args.attr = 'description'
    args.index_type = 'eq'
    args.matching_rule = None
    args.reindex = False
    args.json = False
    args.just_names = False
    args.add_type = None
    args.del_type = None
    args.add_mr = None
    args.del_mr = None

    # Add an index
    backend_add_index(topology_st.standalone, None, None, args)
    check_output("added index")

    # List indexes
    backend_list_index(topology_st.standalone, None, None, args)
    check_output("cn: description")

    # Modify index (Add type)
    args.add_type = ['sub']
    backend_set_index(topology_st.standalone, None, None, args)
    args.add_type = None
    check_output("successfully updated")

    # Verify type was added
    args.attr = ['description']
    backend_get_index(topology_st.standalone, None, None, args)
    check_output("nsindextype: sub")

    # Remove index type sub
    args.attr = 'description'

    args.del_type = ['sub']
    backend_set_index(topology_st.standalone, None, None, args)
    args.del_type = None
    check_output("successfully updated")

    # Verify type was removed
    args.attr = ['description']
    backend_get_index(topology_st.standalone, None, None, args)
    check_output("nsindextype: sub", missing=True)

    # Modify index (add MR)
    args.attr = 'description'
    args.add_mr = ['1.1.1.1.1.1']
    backend_set_index(topology_st.standalone, None, None, args)
    args.add_mr = None
    check_output("successfully updated")

    # Verify MR was added
    args.attr = ['description']
    backend_get_index(topology_st.standalone, None, None, args)
    check_output("nsmatchingrule: 1.1.1.1.1.1")

    # Modify index (delete MR)
    args.attr = 'description'
    args.del_mr = ['1.1.1.1.1.1']
    backend_set_index(topology_st.standalone, None, None, args)
    args.del_mr = None
    check_output("successfully updated")

    # Verify MR was added
    args.attr = ['description']
    backend_get_index(topology_st.standalone, None, None, args)
    check_output("nsmatchingrule: 1.1.1.1.1.1", missing=True)

    # Reindex index
    backend_reindex(topology_st.standalone, None, None, args)
    check_output("reindexed database")
    time.sleep(2)

    # Delete index
    backend_del_index(topology_st.standalone, None, None, args)
    check_output("deleted index")

    # Verify index was removed
    backend_list_index(topology_st.standalone, None, None, args)
    check_output("cn: description", missing=True)
def test_user_modify(topology):
    be_args = FakeArgs()

    be_args.be_name = 'userRoot'
    be_args.suffix = DEFAULT_SUFFIX
    be_args.parent_suffix = None
    be_args.create_entries = False
    backend_create(topology.standalone, None, topology.logcap.log, be_args)

    # And add the skeleton objects.
    init_args = FakeArgs()
    init_args.version = INSTALL_LATEST_CONFIG
    initialise(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, init_args)

    # Check that our modify parser works. Modify statements are such as:
    # "add:attr:value". Replace is the exception as "replace:attr:old:new"

    # Check bad syntax
    modify_args = FakeArgs()
    modify_args.selector = "demo_user"
    modify_args.changes = ["tnaohtnsuahtnsouhtns"]

    with pytest.raises(ValueError):
        modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["add:attr:"]
    with pytest.raises(ValueError):
        modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["add:attr"]
    with pytest.raises(ValueError):
        modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["replace::"]
    with pytest.raises(ValueError):
        modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["replace:attr::new"]
    with pytest.raises(ValueError):
        modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["delete:attr:old:new"]
    with pytest.raises(ValueError):
        modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    # Check that even a single bad value causes error
    modify_args.changes = ["add:description:goodvalue", "add:attr:"]
    with pytest.raises(ValueError):
        modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    # check good syntax
    modify_args.changes = ["add:description:testvalue"]
    modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["replace:description:newvalue"]
    modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["delete:description:newvalue"]
    modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["add:description:testvalue"]
    modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    modify_args.changes = ["delete:description:"]
    modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)

    # check mixed type, with multiple actions

    modify_args.changes = ["add:objectclass:nsMemberOf", "add:description:anothervalue"]
    modify(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, modify_args)
Esempio n. 10
0
def test_user_tasks(topology):
    be_args = FakeArgs()

    be_args.be_name = 'userRoot'
    be_args.suffix = DEFAULT_SUFFIX
    be_args.parent_suffix = None
    be_args.create_entries = False
    backend_create(topology.standalone, None, topology.logcap.log, be_args)

    # And add the skeleton objects.
    init_args = FakeArgs()
    init_args.version = INSTALL_LATEST_CONFIG
    initialise(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log,
               init_args)

    # First check that our test user isn't there:
    topology.logcap.flush()
    u_args = FakeArgs()
    u_args.selector = 'testuser'
    u_args.json = False
    with pytest.raises(ldap.NO_SUCH_OBJECT):
        get(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, u_args)

    # Create the user
    topology.logcap.flush()
    u_args.uid = 'testuser'
    # u_args.sn = 'testuser'
    u_args.cn = 'Test User'
    u_args.displayName = 'Test User'
    u_args.homeDirectory = '/home/testuser'
    u_args.uidNumber = '5000'
    u_args.gidNumber = '5000'
    create(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, u_args)

    assert (topology.logcap.contains("Successfully created testuser"))
    # Assert they exist
    topology.logcap.flush()
    get(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, u_args)
    assert (topology.logcap.contains(
        'dn: uid=testuser,ou=people,dc=example,dc=com'))

    # Reset the password

    # Lock the account, check status
    topology.logcap.flush()
    lock(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, u_args)
    assert (topology.logcap.contains('locked'))

    topology.logcap.flush()
    status(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, u_args)
    assert (topology.logcap.contains('locked: True'))

    # Unlock check status
    topology.logcap.flush()
    unlock(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, u_args)
    assert (topology.logcap.contains('unlocked'))

    topology.logcap.flush()
    status(topology.standalone, DEFAULT_SUFFIX, topology.logcap.log, u_args)
    assert (topology.logcap.contains('locked: False'))

    # Enroll a dummy cert

    # Enroll a dummy sshkey

    # Delete it
    topology.logcap.flush()
    u_args.dn = 'uid=testuser,ou=people,dc=example,dc=com'
    delete(topology.standalone,
           DEFAULT_SUFFIX,
           topology.logcap.log,
           u_args,
           warn=False)
    assert (topology.logcap.contains(
        'Successfully deleted uid=testuser,ou=people,dc=example,dc=com'))