def test_commit_configdocs(self):
        """
        Tests the CommitConfigDocsResource method commit_configdocs
        """
        ccdr = CommitConfigDocsResource()
        commit_resp = None
        with patch.object(ConfigdocsHelper, 'tag_buffer') as mock_method:
            helper = ConfigdocsHelper(CTX)
            helper.is_buffer_empty = lambda: False
            helper.get_validations_for_revision = lambda x: {
                'status': 'Success'
            }
            helper.get_revision_id = lambda x: 1
            commit_resp = ccdr.commit_configdocs(helper, False, False)

        mock_method.assert_called_once_with('committed')
        assert commit_resp['status'] == 'Success'

        commit_resp = None
        with patch.object(ConfigdocsHelper, 'tag_buffer') as mock_method:
            helper = ConfigdocsHelper(CTX)
            helper.is_buffer_empty = lambda: False
            helper.get_validations_for_revision = (
                lambda x: {
                    'status': 'Failure',
                    'code': '400 Bad Request',
                    'message': 'this is a mock response'
                })
            helper.get_revision_id = lambda x: 1
            commit_resp = ccdr.commit_configdocs(helper, False, False)
        assert '400' in commit_resp['code']
        assert commit_resp['message'] is not None
        assert commit_resp['status'] == 'Failure'
Exemplo n.º 2
0
def test_is_buffer_emtpy():
    """
    Test the method to check if the configdocs buffer is empty
    """
    helper = ConfigdocsHelper(CTX)
    helper._get_revision_dict = lambda: REV_BUFFER_DICT
    assert not helper.is_buffer_empty()

    helper._get_revision_dict = lambda: REV_BUFF_EMPTY_DICT
    assert helper.is_buffer_empty()

    helper._get_revision_dict = lambda: REV_NO_COMMIT_DICT
    assert not helper.is_buffer_empty()

    helper._get_revision_dict = lambda: REV_EMPTY_DICT
    assert helper.is_buffer_empty()
    def test_commit_configdocs_buffer_err(self):
        """
        Tests the CommitConfigDocsResource method commit_configdocs
        """
        ccdr = CommitConfigDocsResource()

        with pytest.raises(ApiError):
            helper = ConfigdocsHelper(CTX)
            helper.is_buffer_empty = lambda: True
            helper.get_validations_for_revision = lambda x: {
                'status': 'Success'
            }
            ccdr.commit_configdocs(helper, False, False)
def test_is_buffer_empty():
    """
    Test the method to check if the configdocs buffer is empty
    """
    helper = ConfigdocsHelper(CTX)

    # BUFFER revision is none, short circuit case (no buffer revision)
    # buffer is empty.
    helper._get_revision_dict = lambda: REV_BUFF_EMPTY_DICT
    assert helper.is_buffer_empty()

    # BUFFER revision is none, also a short circuit case (no revisions at all)
    # buffer is empty
    helper._get_revision_dict = lambda: REV_EMPTY_DICT
    assert helper.is_buffer_empty()

    # BUFFER revision is not none, collections have been modified
    # buffer is NOT empty.
    helper._get_revision_dict = lambda: REV_BUFFER_DICT
    helper.deckhand.get_diff = (
        lambda old_revision_id, new_revision_id: DIFF_BUFFER_DICT)
    assert not helper.is_buffer_empty()

    # BUFFER revision is not none, all collections unmodified
    # buffer is empty.
    helper._get_revision_dict = lambda: REV_NO_COMMIT_DICT
    helper.deckhand.get_diff = (
        lambda old_revision_id, new_revision_id: UNMOD_BUFFER_DICT)
    assert helper.is_buffer_empty()

    # BUFFER revision is not none, no collections listed (deleted, rollback 0)
    # buffer is empty.
    helper._get_revision_dict = lambda: REV_NO_COMMIT_DICT
    helper.deckhand.get_diff = (
        lambda old_revision_id, new_revision_id: EMPTY_BUFFER_DICT)
    assert helper.is_buffer_empty()
    def test_commit_configdocs_dryrun(self):
        """
        Tests the CommitConfigDocsResource method commit_configdocs
        """
        ccdr = CommitConfigDocsResource()
        commit_resp = None
        with patch.object(ConfigdocsHelper, 'tag_buffer') as mock_method:
            helper = ConfigdocsHelper(CTX)
            helper.is_buffer_empty = lambda: False
            helper.get_validations_for_revision = lambda x: {
                'status': 'Success'
            }
            helper.get_revision_id = lambda x: 1
            commit_resp = ccdr.commit_configdocs(helper, False, True)

        assert '200' in commit_resp['code']
        assert commit_resp['message'] == 'DRYRUN'
        assert commit_resp['status'] == 'Success'
    def test_commit_configdocs_force(self):
        """
        Tests the CommitConfigDocsResource method commit_configdocs
        """
        ccdr = CommitConfigDocsResource()
        commit_resp = None
        with patch.object(ConfigdocsHelper, 'tag_buffer') as mock_method:
            helper = ConfigdocsHelper(CTX)
            helper.is_buffer_empty = lambda: False
            helper.get_validations_for_revision = lambda x: {
                'status': 'Failure'
            }
            helper.get_revision_id = lambda x: 1
            commit_resp = ccdr.commit_configdocs(helper, True, False)

        mock_method.assert_called_once_with('committed')
        assert '200' in commit_resp['code']
        assert 'FORCED' in commit_resp['message']
        assert commit_resp['status'] == 'Failure'
Exemplo n.º 7
0
def test_is_buffer_valid_for_bucket():
    """
    def is_buffer_valid_for_bucket(self, collection_id, buffermode)
    """
    def set_revision_dict(helper, revision_dict, diff_dict):
        helper._get_revision_dict = lambda: revision_dict
        helper.deckhand.get_diff = lambda: diff_dict

    helper = ConfigdocsHelper(CTX)
    helper._get_revision_dict = lambda: REV_BUFFER_DICT
    helper.deckhand.get_diff = (
        lambda old_revision_id, new_revision_id: DIFF_BUFFER_DICT)
    helper.deckhand.rollback = lambda target_revision_id: (set_revision_dict(
        helper, REV_BUFF_EMPTY_DICT, DIFF_BUFF_EMPTY_DICT))
    # patch the deckhand client method to set to empty if reset_to_empty
    # is invoked.
    helper.deckhand.reset_to_empty = lambda: (set_revision_dict(
        helper, REV_EMPTY_DICT, DIFF_EMPTY_DICT))

    # can add 'mop' on append, it was unmodified in buffer
    # can add 'water' on append, it was not anywhere before
    # can't add 'slop' on append, it was deleted (modified in buffer)
    # can't add 'chum' on append, it is already in buffer
    # can't add anything on rejectoncontents
    # can add anything on replace
    assert helper.is_buffer_valid_for_bucket('mop', BufferMode.APPEND)
    assert helper.is_buffer_valid_for_bucket('water', BufferMode.APPEND)
    assert not helper.is_buffer_valid_for_bucket('slop', BufferMode.APPEND)
    assert not helper.is_buffer_valid_for_bucket('chum', BufferMode.APPEND)
    assert not helper.is_buffer_valid_for_bucket('new',
                                                 BufferMode.REJECTONCONTENTS)

    # because of the patched methods above, replace mode will set the
    # buffer/diff to values as if it were rolled back.
    assert helper.is_buffer_valid_for_bucket('mop', BufferMode.REPLACE)
    # should be able to replace mode even if no buffer contents.
    assert helper.is_buffer_valid_for_bucket('mop', BufferMode.REPLACE)
    # in rolled back state as per last two commands, should be ok
    # to use rejectoncontents to add.
    assert helper.is_buffer_valid_for_bucket('mop',
                                             BufferMode.REJECTONCONTENTS)

    # set up as if there is no committed revision yet
    helper._get_revision_dict = lambda: REV_NO_COMMIT_DICT
    helper.deckhand.get_diff = (
        lambda old_revision_id, new_revision_id: DIFF_NO_COMMIT_DICT)

    assert helper.is_buffer_valid_for_bucket('slop', BufferMode.APPEND)
    assert helper.is_buffer_valid_for_bucket('chum', BufferMode.APPEND)
    # buffer is not empty, reject on contents.
    assert not helper.is_buffer_valid_for_bucket('new',
                                                 BufferMode.REJECTONCONTENTS)

    # This should rollback to "nothing" using reset to empty.
    assert helper.is_buffer_valid_for_bucket('mop', BufferMode.REPLACE)
    assert helper.is_buffer_empty()

    # set up as if there is nothing in deckhand.
    helper._get_revision_dict = lambda: REV_EMPTY_DICT
    helper.deckhand.get_diff = (
        lambda old_revision_id, new_revision_id: DIFF_EMPTY_DICT)
    # should be able to add in any mode.
    assert helper.is_buffer_valid_for_bucket('slop', BufferMode.APPEND)
    assert helper.is_buffer_valid_for_bucket('chum', BufferMode.APPEND)
    assert helper.is_buffer_valid_for_bucket('new',
                                             BufferMode.REJECTONCONTENTS)
    assert helper.is_buffer_valid_for_bucket('mop', BufferMode.REPLACE)