How to use the octodns.provider.base.BaseProvider function in octodns

def test_base_provider(self):
        with self.assertRaises(NotImplementedError) as ctx:
            BaseProvider('base')
        self.assertEquals('Abstract base class, log property missing',
                          ctx.exception.message)

        class HasLog(BaseProvider):
            log = getLogger('HasLog')

        with self.assertRaises(NotImplementedError) as ctx:
            HasLog('haslog')
        self.assertEquals('Abstract base class, SUPPORTS_GEO property missing',
                          ctx.exception.message)

        class HasSupportsGeo(HasLog):
            SUPPORTS_GEO = False

        zone = Zone('unit.tests.', [])
        with self.assertRaises(NotImplementedError) as ctx:

def test_base_provider(self):
        with self.assertRaises(NotImplementedError) as ctx:
            BaseProvider('base')
        self.assertEquals('Abstract base class, log property missing',
                          ctx.exception.message)

        class HasLog(BaseProvider):
            log = getLogger('HasLog')

        with self.assertRaises(NotImplementedError) as ctx:
            HasLog('haslog')
        self.assertEquals('Abstract base class, SUPPORTS_GEO property missing',
                          ctx.exception.message)

        class HasSupportsGeo(HasLog):
            SUPPORTS_GEO = False

        zone = Zone('unit.tests.', [])
        with self.assertRaises(NotImplementedError) as ctx:
            HasSupportsGeo('hassupportesgeo').populate(zone)
        self.assertEquals('Abstract base class, SUPPORTS property missing',
                          ctx.exception.message)

def test___init__(self, *_):
        self.assertIsInstance(GoogleCloudProvider(id=1,
                                                  credentials_file="test",
                                                  project="unit test"),
                              BaseProvider)

        self.assertIsInstance(GoogleCloudProvider(id=1),
                              BaseProvider)

def test___init__(self, *_):
        self.assertIsInstance(GoogleCloudProvider(id=1,
                                                  credentials_file="test",
                                                  project="unit test"),
                              BaseProvider)

        self.assertIsInstance(GoogleCloudProvider(id=1),
                              BaseProvider)

from __future__ import absolute_import, division, print_function, \
    unicode_literals

import shlex
import time
from logging import getLogger
from uuid import uuid4
import re

from google.cloud import dns

from .base import BaseProvider
from ..record import Record


class GoogleCloudProvider(BaseProvider):
    """
    Google Cloud DNS provider

    google_cloud:
        class: octodns.provider.googlecloud.GoogleCloudProvider
        # Credentials file for a service_account or other account can be
        # specified with the GOOGLE_APPLICATION_CREDENTIALS environment
        # variable. (https://console.cloud.google.com/apis/credentials)
        #
        # The project to work on (not required)
        # project: foobar
        #
        # The File with the google credentials (not required). If used, the
        # "project" parameter needs to be set, else it will fall back to the
        #  "default credentials"
        # credentials_file: ~/google_cloud_credentials_file.json

def _check_endswith_dot(string):
    return string if string.endswith('.') else string + '.'


def _parse_azure_type(string):
    '''Converts string representing an Azure RecordSet type to usual type.

        :param string: the Azure type. eg: 
        :type  string: str

        :type return: str
    '''
    return string.split('/')[len(string.split('/')) - 1]


class AzureProvider(BaseProvider):
    '''
    Azure DNS Provider

    azuredns.py:
        class: octodns.provider.azuredns.AzureProvider
        # Current support of authentication of access to Azure services only
        # includes using a Service Principal:
        # https://docs.microsoft.com/en-us/azure/azure-resource-manager/
        #                        resource-group-create-service-principal-portal
        # The Azure Active Directory Application ID (aka client ID):
        client_id:
        # Authentication Key Value: (note this should be secret)
        key:
        # Directory ID (aka tenant ID):
        directory_id:
        # Subscription ID:

zone_id = self.domains.get(zone_name, False)
        path = '/{}/records'.format(zone_id)

        # change ALIAS records to ANAME
        if params['type'] == 'ALIAS':
            params['type'] = 'ANAME'

        self._request('POST', path, data=params)

    def record_delete(self, zone_name, record_id):
        zone_id = self.domains.get(zone_name, False)
        path = '/{}/records/{}'.format(zone_id, record_id)
        self._request('DELETE', path)


class DnsMadeEasyProvider(BaseProvider):
    '''
    DNSMadeEasy DNS provider using v2.0 API

    dnsmadeeasy:
        class: octodns.provider.dnsmadeeasy.DnsMadeEasyProvider
        # Your DnsMadeEasy api key (required)
        api_key: env/DNSMADEEASY_API_KEY
        # Your DnsMadeEasy secret key (required)
        secret_key: env/DNSMADEEASY_SECRET_KEY
        # Whether or not to use Sandbox environment
        # (optional, default is false)
        sandbox: true
    '''
    SUPPORTS_GEO = False
    SUPPORTS_DYNAMIC = False
    SUPPORTS = set(('A', 'AAAA', 'ALIAS', 'CAA', 'CNAME', 'MX',

from __future__ import absolute_import, division, print_function, \
    unicode_literals

from logging import getLogger
from itertools import chain
from nsone import NSONE
from nsone.rest.errors import RateLimitException, ResourceException
from incf.countryutils import transformations
from time import sleep

from ..record import Record
from .base import BaseProvider


class Ns1Provider(BaseProvider):
    '''
    Ns1 provider

    nsone:
        class: octodns.provider.ns1.Ns1Provider
        api_key: env/NS1_API_KEY
    '''
    SUPPORTS_GEO = True
    SUPPORTS = set(('A', 'AAAA', 'ALIAS', 'CAA', 'CNAME', 'MX', 'NAPTR', 'NS',
                    'PTR', 'SPF', 'SRV', 'TXT'))

    ZONE_NOT_FOUND_MESSAGE = 'server error: zone not found'

    def __init__(self, id, api_key, *args, **kwargs):
        self.log = getLogger('Ns1Provider[{}]'.format(id))
        self.log.debug('__init__: id=%s, api_key=***', id)

from __future__ import absolute_import, division, print_function, \
    unicode_literals

import base64
import binascii
import logging
from collections import defaultdict

import ovh
from ovh import ResourceNotFoundError

from octodns.record import Record
from .base import BaseProvider


class OvhProvider(BaseProvider):
    """
    OVH provider using API v6

    ovh:
        class: octodns.provider.ovh.OvhProvider
        # OVH api v6 endpoint
        endpoint: ovh-eu
        # API application key
        application_key: 1234
        # API application secret
        application_secret: 1234
        # API consumer key
        consumer_key: 1234
    """

    SUPPORTS_GEO = False

assert s
    assert s[-1] == '.'
    return s[:-1]


def escape_semicolon(s):
    assert s
    return s.replace(';', '\\;')


def unescape_semicolon(s):
    assert s
    return s.replace('\\;', ';')


class RackspaceProvider(BaseProvider):
    SUPPORTS_GEO = False
    SUPPORTS_DYNAMIC = False
    SUPPORTS = set(('A', 'AAAA', 'ALIAS', 'CNAME', 'MX', 'NS', 'PTR', 'SPF',
                    'TXT'))
    TIMEOUT = 5

    def __init__(self, id, username, api_key, ratelimit_delay=0.0, *args,
                 **kwargs):
        '''
        Rackspace API v1 Provider

        rackspace:
            class: octodns.provider.rackspace.RackspaceProvider
            # The the username to authenticate with (required)
            username: username
            # The api key that grants access for that user (required)