Пример #1
0
def get_mock():
    ysc = youtube_status_code
    yu = youtube_url
    yc = youtube_cookies
    yt = youtube_text
    yh = youtube_headers
    yosc = youtube_oembed_status_code
    you = youtube_oembed_url
    yoh = youtube_oembed_headers
    yot = youtube_oembed_text

    mock_obj_1 = Mock()
    mock_obj_1.status_code = ysc
    mock_obj_1.url = yu
    mock_obj_1.headers = yh
    mock_obj_1.cookies = yc
    mock_obj_1.text = yt
    mock_obj_1.json = lambda: json.loads(mock_obj_1.text)

    mock_obj_2 = Mock()
    mock_obj_2.status_code = 200
    mock_obj_2.url = you
    mock_obj_2.headers = yoh
    mock_obj_2.text = yot
    mock_obj_2.json = lambda: json.loads(mock_obj_2.text)

    return [mock_obj_1, mock_obj_1, mock_obj_2]
    def test_content_item_deploy_fail(self):
        # failed deployment
        response_deployment_state = Mock()
        response_deployment_state.cookies = {}
        response_deployment_state.json = Mock(return_value={"value": {
            'name': 'def',
            'id': 'id'}})

        response_failed_deployment = Mock()
        response_failed_deployment.cookies = {}
        response_failed_deployment.json = Mock(return_value={"value": {
            'name': 'def',
            'succeeded': False,
            'id': 'id'}})

        _responses = [self.response_logout,
                      response_failed_deployment,
                      response_deployment_state,
                      self.response_login]

        def _fake_response(*argc, **kwargs):
            return _responses.pop()

        requests = Mock()
        requests.request = _fake_response
        # check correct deployment
        with patch("cloudify_vsphere.contentlibrary.requests", requests):
            with self.assertRaises(NonRecoverableError):
                cl = contentlibrary.ContentLibrary({'host': 'host',
                                                    'username': '******',
                                                    'password': '******',
                                                    'allow_insecure': True})
                cl.content_item_deploy(
                    "abc", {'target': '_target'}, {'param': '_param'})
            cl.__del__()
    def test_init(self):
        requests = Mock()
        requests.request = Mock(return_value=self.response_login)
        with patch("cloudify_vsphere.contentlibrary.requests", requests):
            # correct session id
            cl = contentlibrary.ContentLibrary({'host': 'host',
                                                'username': '******',
                                                'password': '******',
                                                'allow_insecure': True})
            cl.__del__()

            # wrong session id
            response = Mock()
            response.json = Mock(return_value={"value": 'other_id'})
            response.cookies = {'vmware-api-session-id': 'session_id'}
            requests.request = Mock(return_value=response)
            with self.assertRaises(NonRecoverableError):
                contentlibrary.ContentLibrary({'host': 'host',
                                               'username': '******',
                                               'password': '******',
                                               'allow_insecure': True})
            # no response
            response = Mock()
            response.json = Mock(return_value={})
            response.cookies = {}
            requests.request = Mock(return_value=response)
            with self.assertRaises(NonRecoverableError):
                contentlibrary.ContentLibrary({'host': 'host',
                                               'username': '******',
                                               'password': '******',
                                               'allow_insecure': True})
    def test_get_techloan_data(self):
        """
        Tests that getting the data from the techloan instance
        returns the expected data and raises errors appropriately
        """
        test_json = self.load_json_file('cte_techloan_type_data.json')
        status_codes = [200, 400]
        # Mock a get call with different status codes returned
        for status in status_codes:
            mock = Mock()
            mock.status_code = status
            mock.json = Mock(return_value=test_json)

            with patch.object(requests, 'get', return_value=mock):
                techloan_data = cte_techloan.get_techloan_data()
                if (status == 200):
                    self.assertEqual(techloan_data, test_json)
                else:
                    self.assertIs(techloan_data, None)

        # Mock a call with invalid techloan_data
        test_json = 1
        mock = Mock()
        mock.status_code = 200
        mock.json = Mock(return_value=test_json)

        with patch.object(requests, 'get', return_value=mock):
            techloan_data = cte_techloan.get_techloan_data()
            self.assertIs(techloan_data, None)
    def test_content_library_get(self):
        response_list = Mock()
        response_list.cookies = {}
        response_list.json = Mock(return_value={"value": ['abc']})

        response_library = Mock()
        response_library.cookies = {}
        response_library.json = Mock(return_value={"value": {'name': 'abc',
                                                             'id': 'id'}})

        _responses = [self.response_logout,
                      response_library,
                      response_list,
                      self.response_login]

        def _fake_response(*argc, **kwargs):
            return _responses.pop()

        requests = Mock()
        requests.request = _fake_response
        # check content libraries list
        with patch("cloudify_vsphere.contentlibrary.requests", requests):
            cl = contentlibrary.ContentLibrary({'host': 'host',
                                                'username': '******',
                                                'password': '******',
                                                'allow_insecure': True})

            self.assertEqual(cl.content_library_get("abc"),
                             {'name': 'abc', 'id': 'id'})
            cl.__del__()
Пример #6
0
 def mock_response(self, content, status_code=200, bad_json=False):
     mock = Mock(spec=requests.Response)
     mock.content = content
     mock.ok = (status_code >= 200 and status_code < 300)
     mock.status_code = status_code
     mock.iter_content = lambda size: mock.content
     if bad_json:
         mock.json = self._raise(ValueError)
     else:
         mock.json = lambda: json.loads(mock.content or '""')
     mock.raise_for_status = lambda: None
     return mock
Пример #7
0
    def test_get_digest_subscribers_multi_page(self):
        """
        """

        # multi page result
        expected_multi_p1 = {
            "count": 5,
            "next": "not none",
            "previous": None,
            "results": [mkresult(1), mkresult(2), mkresult(3)]
        }
        expected_multi_p2 = {
            "count": 5,
            "next": None,
            "previous": "not none",
            "results": [mkresult(4), mkresult(5)]
        }

        expected_pages = [expected_multi_p1, expected_multi_p2]
        def side_effect(*a, **kw):
            return expected_pages.pop(0)

        m = Mock()
        with patch('requests.get', return_value=m) as p:
            res = [] 
            m.json = expected_multi_p1 
            g = get_digest_subscribers()
            res.append(g.next())
            p.assert_called_once_with(
                self.expected_api_url,
                params=self.expected_params,
                headers=self.expected_headers)
            res.append(g.next())
            res.append(g.next()) # result 3, end of page
            self.assertEqual([
                mkexpected(mkresult(1)), 
                mkexpected(mkresult(2)), 
                mkexpected(mkresult(3))], res)
            # still should only have called requests.get() once
            self.assertEqual(1, p.call_count)
            
            p.reset_mock() # reset call count
            self.expected_params['page']=2
            m.json = expected_multi_p2
            self.assertEqual(mkexpected(mkresult(4)), g.next())
            p.assert_called_once_with(
                self.expected_api_url,
                params=self.expected_params,
                headers=self.expected_headers)
            self.assertEqual(mkexpected(mkresult(5)), g.next())
            self.assertEqual(1, p.call_count)
            self.assertRaises(StopIteration, g.next)
Пример #8
0
    def test_relay_with_inline_response(self, mock_post):
        mock_response = Mock()
        mock_response.headers
        mock_response.headers = Headers({
            'Content-Type': ['application/json']
        })

        mock_response.json = Mock()
        mock_response.json.return_value = succeed([{
            'text': 'the-outbound-reply'
        }])

        mock_post.return_value = succeed(mock_response)

        _, r = yield self.mk_relay('http://*****:*****@example.com/foo')

        mock_protocol = Mock()
        mock_protocol.send_message = Mock()
        mock_protocol.send_message.return_value = None

        r.connections['user-id'] = mock_protocol

        yield r.relay('user-id', {'foo': 'bar'})

        mock_protocol.send_message.assert_called_with({
            'text': 'the-outbound-reply'
        })
Пример #9
0
    def test_descargar_actualizacion(self, mock_get):
        '''
        Prueba la descarga de la ultima version desde el servidor. Debe
        retornar una lista de clases de trafico en forma de diccionarios.
        '''
        # preparo datos
        clases = [
            {
                'id': 1,
                'nombre': 'foo',
                'descripcion': 'bar',
            },
            {
                'id': 2,
                'nombre': 'fulano',
                'descripcion': 'mengano',
            },
        ]

        mock_response = Mock()
        mock_response.status_code = 200
        mock_response.json = Mock(return_value={'clases': clases})
        mock_get.return_value = mock_response
        # llamo metodo a probar
        descarga = self.actualizador.descargar_actualizacion()
        # verifico que todo este bien
        for clase in clases:
            assert clase in descarga
Пример #10
0
    def test_3login_flow(self):
        ver_code_of_last_user, last_uid = DBSession.query(User.ver_code, User.id).all()[-1]
        self.assert_(ver_code_of_last_user, 'Wrong order of tests')
        req = DummyRequest(path='linkedin_confirm/%s' % ver_code_of_last_user,
                           matchdict={'code': ver_code_of_last_user}, user=self.founder)
        auth_uids = []
        confirm_acc.remember = lambda x, y: auth_uids.append(y)
        ret = confirm_acc.linkedin_confirm_view(req)
        self.assert_(last_uid in auth_uids, 'User should be logged in')
        self.assert_(isinstance(ret, HTTPFound), 'Should redirect to linkedin')

        # now test the linkedin return but mock out all the linkedin credential checks
        req2 = Mock()
        req2.params = {'code': 'test'}
        req2.authenticated_userid = last_uid
        login.get_oauth_flow_linkedin = Mock()
        login.requests = Mock()
        linkedin_user_resp = Mock()
        linkedin_email = '*****@*****.**'
        linkedin_user_resp.json = {'id': 'dummyLinkedinID', 'emailAddress': linkedin_email}
        login.requests.get = lambda *x, **k: linkedin_user_resp
        login.check_csrf_token = Mock()
        # end of mocks

        self.assert_(self.get_linkedin_email_db(last_uid) != linkedin_email, 'Linkedin email should not be set yet')
        ret = login.oauthcallback_view(req2)
        # oauth callback view calls complete_confirm_acc
        self.assert_(isinstance(ret, HTTPFound), 'Should redirect to profile')
        self.assert_(self.get_linkedin_email_db(last_uid) == linkedin_email,
                     'Linkedin email should be set by complete_confirm_acc')
Пример #11
0
 def _mock_response(self, requests_mock, json_result, status_code=200,
                    content=None):
     response_mock = Mock()
     response_mock.status_code = status_code
     response_mock.json = Mock(return_value=json_result)
     response_mock.content = content
     requests_mock.return_value = response_mock
Пример #12
0
class SessionResourceTestCase(TestCase):
    def setUp(self):
        self.schema_url = "/schema"

        self.response = Mock()
        self.response.headers = {"content-type": "application/json; profile=%s" % self.schema_url}

        self.session = Session()

        patch.object(self.session, "request").start()
        self.session.request.return_value = self.response

    def tearDown(self):
        patch.stopall()

    @patch("pluct.session.Resource.from_response")
    @patch("pluct.session.LazySchema")
    def test_creates_resource_from_response(self, LazySchema, from_response):
        LazySchema.return_value = "fake schema"

        self.session.resource("/")

        LazySchema.assert_called_with(href=self.schema_url, session=self.session)

        from_response.assert_called_with(response=self.response, session=self.session, schema="fake schema")

    @patch("pluct.session.Schema")
    def test_creates_schema_from_response(self, Schema):
        self.session.schema("/")
        Schema.assert_called_with("/", raw_schema=self.response.json(), session=self.session)
    def test_load_post(self, RequestsGetMock):

        # set up a mock response with stubbed json to simulate the API
        def read_post_json():
            with open(os.path.join(os.path.dirname(__file__), "data", "post.json")) as post_json_file:
                return json.load(post_json_file)

        mock_response = Mock(Response)
        mock_response.ok = True
        mock_response.text = "some text"
        mock_response.json = read_post_json

        RequestsGetMock.return_value = mock_response

        # call we're testing
        post = self.loader.load_post(1)

        # some validations
        self.assertIsInstance(post, Post)
        self.assertEqual(post.wp_id, 1)
        self.assertEqual(post.title, "This is a Test Post")
        self.assertEqual(post.author.name, "testauthor")
        self.assertEqual(post.categories.first().name, "News")
        self.assertEqual(post.tags.first().name, "Testing")
        self.assertEqual(post.attachments.first().url, "https://test.local/testpost.jpg")
Пример #14
0
def default_args():
    args = Mock()
    args.conf_file = '.lamvery.yml'
    args.alias = 'foo'
    args.version = '1'
    args.json = '{"foo": "bar"}'
    return args
 def test_authorize_sets_correct_session_if_user_can_sign_in(
         self,
         oauth_authorization_url_patch,
         oauth_get_patch,
         oauth_fetch_token_patch):
     token = "token_token"
     user = {
         'permissions': ['signin'],
         'uid': "bleep_bloop_blarp"
     }
     oauth_get_response = Mock()
     oauth_get_response.json = Mock(return_value={
         'user': user
     })
     oauth_get_patch.return_value = oauth_get_response
     oauth_fetch_token_patch.return_value = token
     with self.client.session_transaction() as sess:
         sess['oauth_state'] = "foo"
     response = self.client.get(
         '/auth/gds/callback')
     self.assert_session_contains('oauth_user', user)
     self.assert_session_contains('oauth_token', token)
     self.assert_flashes('You have been successfully signed in')
     assert_equal(response.headers['Location'], 'http://localhost/')
     assert_equal(response.status_code, 302)
Пример #16
0
def complex_409_surge_error():
    code = 'surge'

    mock_error = Mock(
        status_code=http.STATUS_CONFLICT,
        headers=http.DEFAULT_CONTENT_HEADERS,
    )

    error_response = {
        'meta': {
            'surge_confirmation': {
                'href': 'api.uber.com/v1/surge-confirmations/abc',
                'surge_confirmation_id': 'abc',
            },
        },
        'errors': [
            {
                'status': http.STATUS_CONFLICT,
                'code': code,
                'title': http.ERROR_CODE_DESCRIPTION_DICT[code],
            },
        ],
    }

    mock_error.json = Mock(return_value=error_response)
    return mock_error
Пример #17
0
    def test_put_validation_error(self):
        path = 'foo'
        url = 'https://api.jirafe.com/v1/id/foo'
        data_string = '{"bar":"baz"}'
        auth_header = "some header"
        session = Mock()
        session.site_id = 'id'
        session.get_header = Mock(return_value=auth_header)
        options = {
            "data": data_string,
            "headers": auth_header
        }
        errors = {
            'foo': 'foo error',
            'bar': 'bar error',
        }
        json_response = {'success': False, 'error_type': 'validation', 'errors': errors}
        put_response = {'errors': errors}
        mock_response = Mock()
        mock_response.json = Mock(return_value=put_response)
        mock_response.status_code = 400
        self.requests.put = Mock(return_value=mock_response)

        actual_response = self.client._put(session, path, data_string)

        self.requests.put.assert_called_with(url, **options)
        self.assertEqual(json_response, actual_response)
Пример #18
0
def http_surge_error():
    code = 'surge'

    mock_error = Mock(
        status_code=http.STATUS_CONFLICT,
        headers=http.DEFAULT_CONTENT_HEADERS,
    )

    error_response = {
        'meta': {
            'surge_confirmation': {
                'href': SURGE_HREF.format(SURGE_ID),
                'surge_confirmation_id': SURGE_ID,
            },
        },
        'errors': [
            {
                'status': http.STATUS_CONFLICT,
                'code': code,
                'title': http.ERROR_CODE_DESCRIPTION_DICT[code],
            },
        ],
    }

    mock_error.json = Mock(return_value=error_response)
    return mock_error
 def test_find_by_name_invalid_collector(self):
     error_response = {'error': "Metric Collector '{}' not found.".format(self.subject.name)}
     response = Mock()
     response.json = Mock(return_value=error_response)
     with patch.object(MetricCollectorDetails, 'request') as metric_collector_details_request:
         metric_collector_details_request.side_effect=KalibroClientRequestError(response)
         MetricCollectorDetails.find_by_name(self.subject.name)
         metric_collector_details_request.assert_called_once
Пример #20
0
def test_box_response_properties_pass_through_to_network_response_properties():
    mock_network_response = Mock(DefaultNetworkResponse)
    box_result = BoxResponse(mock_network_response)
    assert box_result.json() == mock_network_response.json()
    assert box_result.content == mock_network_response.content
    assert box_result.ok == mock_network_response.ok
    assert box_result.status_code == mock_network_response.status_code
    assert box_result.network_response == mock_network_response
Пример #21
0
def get_mock_no_oembed():
    mock = Mock()
    mock.status_code = youtube_status_code
    mock.url = youtube_url
    mock.cookies = youtube_cookies
    mock.text = 'youtube_text'
    mock.json = lambda: json.loads(mock.text)
    return [mock]
Пример #22
0
 def setup_mock_options(cls):
   """set up to get a mock options object."""
   mock_options = Mock()
   mock_options.open_browser = False
   mock_options.shards = None
   mock_options.cluster = None
   mock_options.json = False
   return mock_options
Пример #23
0
 def patch_requests(self, requests_get, status_code=200):
     requests_json = Mock()
     requests_json.json = lambda: self.sample_items
     requests_json.status_code = status_code
     if status_code != 200:
         requests_json.content = "Some error body"
     requests_get.return_value = requests_json
     return requests_get
Пример #24
0
    def mock_get_json_asset(self, asset_file):
        """Mock requests.get result.json with contents of asset_file"""
        get_mock = Mock()

        with open(self.asset_path(asset_file), 'r') as f:
            get_mock.json = Mock(return_value=json.load(f))

        requests.get = Mock(return_value=get_mock)
Пример #25
0
 def test_fetch_macaroon_fails_gracefully_json(self, mocked):
     def boom():
         raise ValueError
     mock_response = Mock()
     mock_response.json = Mock()
     mock_response.json.side_effect = boom
     mocked.return_value = mock_response
     resp = self.jimm.fetch_macaroon()
     self.assertIsNone(resp)
Пример #26
0
 def test_fetch_macaroon_fails_gracefully_macaroon(self, mocked):
     mock_response = Mock()
     mock_response.json = Mock()
     mock_response.json.return_value = {
         'boom': "this fails"
     }
     mocked.return_value = mock_response
     resp = self.jimm.fetch_macaroon()
     self.assertIsNone(resp)
Пример #27
0
 def setup_mock_options(cls):
   """set up to get a mock options object."""
   mock_options = Mock()
   mock_options.json = False
   mock_options.bindings = {}
   mock_options.open_browser = False
   mock_options.cluster = None
   mock_options.wait_until = 'RUNNING'  # or 'FINISHED' for other tests
   return mock_options
Пример #28
0
    def set_rpc_error_response(self, error, id=None):
        response = Mock()
        response.status_code = 200

        data = self.make_response_data(result=None, id=id)
        data.error = error
        response.json = data

        self.response = response
Пример #29
0
    def test_unsuccessful_update(self):
        subject = IdentifiedBase(id=42, attribute='test')
        unsuccessful_response = {'errors': ['A string with an error']}
        response = Mock()
        response.json = Mock(return_value=unsuccessful_response)

        subject._update_request = create_autospec(subject._update_request,
            side_effect=KalibroClientRequestError(response))

        subject.update(attribute='new_value')
Пример #30
0
    def test_geocode_zeroresults(self):
        response = Mock()
        response.status_code = 200
        response.json = Mock(return_value={'results': [], 'status': 'ZERO_RESULTS'})
        get = Mock(return_value=response)

        with self.patch('get', get):
            func = geocode.GeoCodeService().geocode
            error = geocode.ZeroResuls
            self.assertRaises(error, func, 'query')
Пример #31
0
    def test_apply(self):
        provider = HetznerProvider('test', 'token')

        resp = Mock()
        resp.json = Mock()
        provider._client._do = Mock(return_value=resp)

        domain_after_creation = {
            'zone': {
                'id': 'unit.tests',
                'name': 'unit.tests',
                'ttl': 3600,
            }
        }

        # non-existent domain, create everything
        resp.json.side_effect = [
            HetznerClientNotFound,  # no zone in populate
            HetznerClientNotFound,  # no zone during apply
            domain_after_creation,
        ]
        plan = provider.plan(self.expected)

        # No root NS, no ignored, no excluded, no unsupported
        n = len(self.expected.records) - 10
        self.assertEquals(n, len(plan.changes))
        self.assertEquals(n, provider.apply(plan))
        self.assertFalse(plan.exists)

        provider._client._do.assert_has_calls([
            # created the zone
            call('POST', '/zones', None, {
                'name': 'unit.tests',
                'ttl': None,
            }),
            # created all the records with their expected data
            call('POST',
                 '/records',
                 data={
                     'name': '@',
                     'ttl': 300,
                     'type': 'A',
                     'value': '1.2.3.4',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': '@',
                     'ttl': 300,
                     'type': 'A',
                     'value': '1.2.3.5',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': '@',
                     'ttl': 3600,
                     'type': 'CAA',
                     'value': '0 issue "ca.unit.tests"',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': '_imap._tcp',
                     'ttl': 600,
                     'type': 'SRV',
                     'value': '0 0 0 .',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': '_pop3._tcp',
                     'ttl': 600,
                     'type': 'SRV',
                     'value': '0 0 0 .',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': '_srv._tcp',
                     'ttl': 600,
                     'type': 'SRV',
                     'value': '10 20 30 foo-1.unit.tests.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': '_srv._tcp',
                     'ttl': 600,
                     'type': 'SRV',
                     'value': '12 20 30 foo-2.unit.tests.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'aaaa',
                     'ttl': 600,
                     'type': 'AAAA',
                     'value': '2601:644:500:e210:62f8:1dff:feb8:947a',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'cname',
                     'ttl': 300,
                     'type': 'CNAME',
                     'value': 'unit.tests.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'included',
                     'ttl': 3600,
                     'type': 'CNAME',
                     'value': 'unit.tests.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'mx',
                     'ttl': 300,
                     'type': 'MX',
                     'value': '10 smtp-4.unit.tests.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'mx',
                     'ttl': 300,
                     'type': 'MX',
                     'value': '20 smtp-2.unit.tests.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'mx',
                     'ttl': 300,
                     'type': 'MX',
                     'value': '30 smtp-3.unit.tests.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'mx',
                     'ttl': 300,
                     'type': 'MX',
                     'value': '40 smtp-1.unit.tests.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'sub',
                     'ttl': 3600,
                     'type': 'NS',
                     'value': '6.2.3.4.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'sub',
                     'ttl': 3600,
                     'type': 'NS',
                     'value': '7.2.3.4.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'txt',
                     'ttl': 600,
                     'type': 'TXT',
                     'value': 'Bah bah black sheep',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'txt',
                     'ttl': 600,
                     'type': 'TXT',
                     'value': 'have you any wool.',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'txt',
                     'ttl': 600,
                     'type': 'TXT',
                     'value': 'v=DKIM1;k=rsa;s=email;h=sha256;'
                     'p=A/kinda+of/long/string+with+numb3rs',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'www',
                     'ttl': 300,
                     'type': 'A',
                     'value': '2.2.3.6',
                     'zone_id': 'unit.tests',
                 }),
            call('POST',
                 '/records',
                 data={
                     'name': 'www.sub',
                     'ttl': 300,
                     'type': 'A',
                     'value': '2.2.3.6',
                     'zone_id': 'unit.tests',
                 }),
        ])
        self.assertEquals(24, provider._client._do.call_count)

        provider._client._do.reset_mock()

        # delete 1 and update 1
        provider._client.zone_get = Mock(return_value={
            'id': 'unit.tests',
            'name': 'unit.tests',
            'ttl': 3600,
        })
        provider._client.zone_records_get = Mock(return_value=[
            {
                'type': 'A',
                'id': 'one',
                'created': '0000-00-00T00:00:00Z',
                'modified': '0000-00-00T00:00:00Z',
                'zone_id': 'unit.tests',
                'name': 'www',
                'value': '1.2.3.4',
                'ttl': 300,
            },
            {
                'type': 'A',
                'id': 'two',
                'created': '0000-00-00T00:00:00Z',
                'modified': '0000-00-00T00:00:00Z',
                'zone_id': 'unit.tests',
                'name': 'www',
                'value': '2.2.3.4',
                'ttl': 300,
            },
            {
                'type': 'A',
                'id': 'three',
                'created': '0000-00-00T00:00:00Z',
                'modified': '0000-00-00T00:00:00Z',
                'zone_id': 'unit.tests',
                'name': 'ttl',
                'value': '3.2.3.4',
                'ttl': 600,
            },
        ])

        # Domain exists, we don't care about return
        resp.json.side_effect = ['{}']

        wanted = Zone('unit.tests.', [])
        wanted.add_record(
            Record.new(wanted, 'ttl', {
                'ttl': 300,
                'type': 'A',
                'value': '3.2.3.4',
            }))

        plan = provider.plan(wanted)
        self.assertTrue(plan.exists)
        self.assertEquals(2, len(plan.changes))
        self.assertEquals(2, provider.apply(plan))
        # recreate for update, and delete for the 2 parts of the other
        provider._client._do.assert_has_calls([
            call('POST',
                 '/records',
                 data={
                     'name': 'ttl',
                     'ttl': 300,
                     'type': 'A',
                     'value': '3.2.3.4',
                     'zone_id': 'unit.tests',
                 }),
            call('DELETE', '/records/one'),
            call('DELETE', '/records/two'),
            call('DELETE', '/records/three'),
        ],
                                              any_order=True)
Пример #32
0
    def test_apply(self):
        provider = GandiProvider('test_id', 'token')

        # Zone does not exists but can be created.
        with requests_mock() as mock:
            mock.get(ANY,
                     status_code=404,
                     text='{"code": 404, "message": "The resource could not '
                     'be found.", "object": "HTTPNotFound", "cause": '
                     '"Not Found"}')
            mock.post(ANY,
                      status_code=201,
                      text='{"message": "Domain Created"}')

            plan = provider.plan(self.expected)
            provider.apply(plan)

        # Zone does not exists and can't be created.
        with requests_mock() as mock:
            mock.get(ANY,
                     status_code=404,
                     text='{"code": 404, "message": "The resource could not '
                     'be found.", "object": "HTTPNotFound", "cause": '
                     '"Not Found"}')
            mock.post(ANY,
                      status_code=404,
                      text='{"code": 404, "message": "The resource could not '
                      'be found.", "object": "HTTPNotFound", "cause": '
                      '"Not Found"}')

            with self.assertRaises(
                (GandiClientNotFound, GandiClientUnknownDomainName)) as ctx:
                plan = provider.plan(self.expected)
                provider.apply(plan)
            self.assertIn('This domain is not registered at Gandi.',
                          text_type(ctx.exception))

        resp = Mock()
        resp.json = Mock()
        provider._client._request = Mock(return_value=resp)

        with open('tests/fixtures/gandi-zone.json') as fh:
            zone = fh.read()

        # non-existent domain
        resp.json.side_effect = [
            GandiClientNotFound(resp),  # no zone in populate
            GandiClientNotFound(resp),  # no domain during apply
            zone
        ]
        plan = provider.plan(self.expected)

        # No root NS, no ignored, no excluded
        n = len(self.expected.records) - 4
        self.assertEquals(n, len(plan.changes))
        self.assertEquals(n, provider.apply(plan))
        self.assertFalse(plan.exists)

        provider._client._request.assert_has_calls([
            call('GET', '/livedns/domains/unit.tests/records'),
            call('GET', '/livedns/domains/unit.tests'),
            call('POST',
                 '/livedns/domains',
                 data={
                     'fqdn': 'unit.tests',
                     'zone': {}
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'www.sub',
                     'rrset_ttl': 300,
                     'rrset_type': 'A',
                     'rrset_values': ['2.2.3.6']
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'www',
                     'rrset_ttl': 300,
                     'rrset_type': 'A',
                     'rrset_values': ['2.2.3.6']
                 }),
            call(
                'POST',
                '/livedns/domains/unit.tests/records',
                data={
                    'rrset_name':
                    'txt',
                    'rrset_ttl':
                    600,
                    'rrset_type':
                    'TXT',
                    'rrset_values': [
                        'Bah bah black sheep', 'have you any wool.',
                        'v=DKIM1;k=rsa;s=email;h=sha256;p=A/kinda+of/long/string'
                        '+with+numb3rs'
                    ]
                }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'spf',
                     'rrset_ttl': 600,
                     'rrset_type': 'SPF',
                     'rrset_values': ['v=spf1 ip4:192.168.0.1/16-all']
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'ptr',
                     'rrset_ttl': 300,
                     'rrset_type': 'PTR',
                     'rrset_values': ['foo.bar.com.']
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name':
                     'mx',
                     'rrset_ttl':
                     300,
                     'rrset_type':
                     'MX',
                     'rrset_values': [
                         '10 smtp-4.unit.tests.', '20 smtp-2.unit.tests.',
                         '30 smtp-3.unit.tests.', '40 smtp-1.unit.tests.'
                     ]
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'excluded',
                     'rrset_ttl': 3600,
                     'rrset_type': 'CNAME',
                     'rrset_values': ['unit.tests.']
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'dname',
                     'rrset_ttl': 300,
                     'rrset_type': 'DNAME',
                     'rrset_values': ['unit.tests.']
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'cname',
                     'rrset_ttl': 300,
                     'rrset_type': 'CNAME',
                     'rrset_values': ['unit.tests.']
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'aaaa',
                     'rrset_ttl': 600,
                     'rrset_type': 'AAAA',
                     'rrset_values': ['2601:644:500:e210:62f8:1dff:feb8:947a']
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name':
                     '_srv._tcp',
                     'rrset_ttl':
                     600,
                     'rrset_type':
                     'SRV',
                     'rrset_values': [
                         '10 20 30 foo-1.unit.tests.',
                         '12 20 30 foo-2.unit.tests.'
                     ]
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name':
                     '@',
                     'rrset_ttl':
                     3600,
                     'rrset_type':
                     'SSHFP',
                     'rrset_values': [
                         '1 1 7491973e5f8b39d5327cd4e08bc81b05f7710b49',
                         '1 1 bf6b6825d2977c511a475bbefb88aad54a92ac73'
                     ]
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': '@',
                     'rrset_ttl': 3600,
                     'rrset_type': 'CAA',
                     'rrset_values': ['0 issue "ca.unit.tests"']
                 }),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': '@',
                     'rrset_ttl': 300,
                     'rrset_type': 'A',
                     'rrset_values': ['1.2.3.4', '1.2.3.5']
                 })
        ])
        # expected number of total calls
        self.assertEquals(17, provider._client._request.call_count)

        provider._client._request.reset_mock()

        # delete 1 and update 1
        provider._client.zone_records = Mock(
            return_value=[{
                'rrset_name': 'www',
                'rrset_ttl': 300,
                'rrset_type': 'A',
                'rrset_values': ['1.2.3.4']
            }, {
                'rrset_name': 'www',
                'rrset_ttl': 300,
                'rrset_type': 'A',
                'rrset_values': ['2.2.3.4']
            }, {
                'rrset_name': 'ttl',
                'rrset_ttl': 600,
                'rrset_type': 'A',
                'rrset_values': ['3.2.3.4']
            }])

        # Domain exists, we don't care about return
        resp.json.side_effect = ['{}']

        wanted = Zone('unit.tests.', [])
        wanted.add_record(
            Record.new(wanted, 'ttl', {
                'ttl': 300,
                'type': 'A',
                'value': '3.2.3.4'
            }))

        plan = provider.plan(wanted)
        self.assertTrue(plan.exists)
        self.assertEquals(2, len(plan.changes))
        self.assertEquals(2, provider.apply(plan))

        # recreate for update, and deletes for the 2 parts of the other
        provider._client._request.assert_has_calls([
            call('DELETE', '/livedns/domains/unit.tests/records/www/A'),
            call('DELETE', '/livedns/domains/unit.tests/records/ttl/A'),
            call('POST',
                 '/livedns/domains/unit.tests/records',
                 data={
                     'rrset_name': 'ttl',
                     'rrset_ttl': 300,
                     'rrset_type': 'A',
                     'rrset_values': ['3.2.3.4']
                 })
        ],
                                                   any_order=True)
Пример #33
0
def mock_transaction_lookup(transaction_id):
    m = Mock(status_code=200)
    m.json = mock_json
    return m
Пример #34
0
def login_with_mlc(
    app,
    name="user",
    scope="profile%20team",
    email="*****@*****.**",
    oauth_id=1337,
    team_name="TestTeam",
    team_oauth_id=1234,
    raise_for_error=True,
):
    with app.test_client() as client, patch.object(
            requests, "get") as fake_get_request, patch.object(
                requests, "post") as fake_post_request:
        client.get("/login")
        with client.session_transaction() as sess:
            nonce = sess["nonce"]

            redirect_url = "{endpoint}?response_type=code&client_id={client_id}&scope={scope}&state={state}".format(
                endpoint=app.config["OAUTH_AUTHORIZATION_ENDPOINT"],
                client_id=app.config["OAUTH_CLIENT_ID"],
                scope=scope,
                state=nonce,
            )

        r = client.get("/oauth", follow_redirects=False)
        assert r.location == redirect_url

        fake_post_response = Mock()
        fake_post_request.return_value = fake_post_response
        fake_post_response.status_code = 200
        fake_post_response.json = lambda: {
            "access_token": "fake_mlc_access_token"
        }

        fake_get_response = Mock()
        fake_get_request.return_value = fake_get_response
        fake_get_response.status_code = 200
        fake_get_response.json = lambda: {
            "id": oauth_id,
            "name": name,
            "email": email,
            "team": {
                "id": team_oauth_id,
                "name": team_name
            },
        }

        client.get(
            "/redirect?code={code}&state={state}".format(code="mlc_test_code",
                                                         state=nonce),
            follow_redirects=False,
        )

        if raise_for_error:
            with client.session_transaction() as sess:
                assert sess["id"]
                assert sess["name"]
                assert sess["type"]
                assert sess["email"]
                assert sess["nonce"]
        return client
Пример #35
0
def fake_empty_graphite_response(*args, **kwargs):
    resp = Mock()
    resp.json = lambda: json.loads(get_content('graphite_null_response.json'))
    resp.status_code = 200
    return resp
    def test_apply(self):
        provider = DnsimpleProvider('test', 'token', 42)

        resp = Mock()
        resp.json = Mock()
        provider._client._request = Mock(return_value=resp)

        # non-existant domain, create everything
        resp.json.side_effect = [
            DnsimpleClientNotFound,  # no zone in populate
            DnsimpleClientNotFound,  # no domain during apply
        ]
        plan = provider.plan(self.expected)

        # No root NS, no ignored
        n = len(self.expected.records) - 2
        self.assertEquals(n, len(plan.changes))
        self.assertEquals(n, provider.apply(plan))

        provider._client._request.assert_has_calls([
            # created the domain
            call('POST', '/domains', data={'name': 'unit.tests'}),
            # created at least one of the record with expected data
            call('POST', '/zones/unit.tests/records', data={
                'content': '20 30 foo-1.unit.tests.',
                'priority': 10,
                'type': 'SRV',
                'name': '_srv._tcp',
                'ttl': 600
            }),
        ])
        # expected number of total calls
        self.assertEquals(27, provider._client._request.call_count)

        provider._client._request.reset_mock()

        # delete 1 and update 1
        provider._client.records = Mock(return_value=[
            {
                'id': 11189897,
                'name': 'www',
                'content': '1.2.3.4',
                'ttl': 300,
                'type': 'A',
            },
            {
                'id': 11189898,
                'name': 'www',
                'content': '2.2.3.4',
                'ttl': 300,
                'type': 'A',
            },
            {
                'id': 11189899,
                'name': 'ttl',
                'content': '3.2.3.4',
                'ttl': 600,
                'type': 'A',
            }
        ])
        # Domain exists, we don't care about return
        resp.json.side_effect = ['{}']

        wanted = Zone('unit.tests.', [])
        wanted.add_record(Record.new(wanted, 'ttl', {
            'ttl': 300,
            'type': 'A',
            'value': '3.2.3.4'
        }))

        plan = provider.plan(wanted)
        self.assertEquals(2, len(plan.changes))
        self.assertEquals(2, provider.apply(plan))
        # recreate for update, and deletes for the 2 parts of the other
        provider._client._request.assert_has_calls([
            call('POST', '/zones/unit.tests/records', data={
                'content': '3.2.3.4',
                'type': 'A',
                'name': 'ttl',
                'ttl': 300
            }),
            call('DELETE', '/zones/unit.tests/records/11189899'),
            call('DELETE', '/zones/unit.tests/records/11189897'),
            call('DELETE', '/zones/unit.tests/records/11189898')
        ], any_order=True)
Пример #37
0
def jenkins_blocked_response(*args, **kwargs):
    resp = Mock()
    resp.json = lambda: json.loads(get_content('jenkins_blocked_response.json')
                                   )
    resp.status_code = 200
    return resp
Пример #38
0
def fake_slow_graphite_response(*args, **kwargs):
    resp = Mock()
    time.sleep(0.1)
    resp.json = lambda: json.loads(get_content('graphite_null_response.json'))
    resp.status_code = 200
    return resp
Пример #39
0
    def test_apply(self):
        provider = GCoreProvider("test_id", url="http://api", token="token")

        # TC: Zone does not exists but can be created.
        with requests_mock() as mock:
            mock.get(ANY,
                     status_code=404,
                     text='{"error":"zone is not found"}')
            mock.post(ANY, status_code=200, text='{"id":1234}')

            plan = provider.plan(self.expected)
            provider.apply(plan)

        # TC: Zone does not exists and can't be created.
        with requests_mock() as mock:
            mock.get(ANY,
                     status_code=404,
                     text='{"error":"zone is not found"}')
            mock.post(
                ANY,
                status_code=400,
                text='{"error":"parent zone is already'
                ' occupied by another client"}',
            )

            with self.assertRaises(
                (GCoreClientNotFound, GCoreClientBadRequest)) as ctx:
                plan = provider.plan(self.expected)
                provider.apply(plan)
            self.assertIn(
                "parent zone is already occupied by another client",
                text_type(ctx.exception),
            )

        resp = Mock()
        resp.json = Mock()
        provider._client._request = Mock(return_value=resp)

        with open("tests/fixtures/gcore-zone.json") as fh:
            zone = fh.read()

        # non-existent domain
        resp.json.side_effect = [
            GCoreClientNotFound(resp),  # no zone in populate
            GCoreClientNotFound(resp),  # no domain during apply
            zone,
        ]
        plan = provider.plan(self.expected)

        # TC: create all
        self.assertEqual(13, len(plan.changes))
        self.assertEqual(13, provider.apply(plan))
        self.assertFalse(plan.exists)

        provider._client._request.assert_has_calls([
            call(
                "GET",
                "http://api/zones/unit.tests/rrsets",
                params={"all": "true"},
            ),
            call("GET", "http://api/zones/unit.tests"),
            call("POST", "http://api/zones", data={"name": "unit.tests"}),
            call(
                "POST",
                "http://api/zones/unit.tests/www.sub.unit.tests./A",
                data={
                    "ttl": 300,
                    "resource_records": [{
                        "content": ["2.2.3.6"]
                    }],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/www.unit.tests./A",
                data={
                    "ttl": 300,
                    "resource_records": [{
                        "content": ["2.2.3.6"]
                    }],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/txt.unit.tests./TXT",
                data={
                    "ttl":
                    600,
                    "resource_records": [
                        {
                            "content": ["Bah bah black sheep"]
                        },
                        {
                            "content": ["have you any wool."]
                        },
                        {
                            "content": [
                                "v=DKIM1;k=rsa;s=email;h=sha256;p=A/kinda+"
                                "of/long/string+with+numb3rs"
                            ]
                        },
                    ],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/sub.unit.tests./NS",
                data={
                    "ttl":
                    3600,
                    "resource_records": [
                        {
                            "content": ["6.2.3.4."]
                        },
                        {
                            "content": ["7.2.3.4."]
                        },
                    ],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/ptr.unit.tests./PTR",
                data={
                    "ttl": 300,
                    "resource_records": [
                        {
                            "content": ["foo.bar.com."]
                        },
                    ],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/mx.unit.tests./MX",
                data={
                    "ttl":
                    300,
                    "resource_records": [
                        {
                            "content": [10, "smtp-4.unit.tests."]
                        },
                        {
                            "content": [20, "smtp-2.unit.tests."]
                        },
                        {
                            "content": [30, "smtp-3.unit.tests."]
                        },
                        {
                            "content": [40, "smtp-1.unit.tests."]
                        },
                    ],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/excluded.unit.tests./CNAME",
                data={
                    "ttl": 3600,
                    "resource_records": [{
                        "content": ["unit.tests."]
                    }],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/cname.unit.tests./CNAME",
                data={
                    "ttl": 300,
                    "resource_records": [{
                        "content": ["unit.tests."]
                    }],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/aaaa.unit.tests./AAAA",
                data={
                    "ttl":
                    600,
                    "resource_records": [{
                        "content": ["2601:644:500:e210:62f8:1dff:feb8:947a"]
                    }],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/_srv._tcp.unit.tests./SRV",
                data={
                    "ttl":
                    600,
                    "resource_records": [
                        {
                            "content": [10, 20, 30, "foo-1.unit.tests."]
                        },
                        {
                            "content": [12, 20, 30, "foo-2.unit.tests."]
                        },
                    ],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/_pop3._tcp.unit.tests./SRV",
                data={
                    "ttl": 600,
                    "resource_records": [{
                        "content": [0, 0, 0, "."]
                    }],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/_imap._tcp.unit.tests./SRV",
                data={
                    "ttl": 600,
                    "resource_records": [{
                        "content": [0, 0, 0, "."]
                    }],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/unit.tests./A",
                data={
                    "ttl":
                    300,
                    "resource_records": [
                        {
                            "content": ["1.2.3.4"]
                        },
                        {
                            "content": ["1.2.3.5"]
                        },
                    ],
                },
            ),
        ])
        # expected number of total calls
        self.assertEqual(16, provider._client._request.call_count)

        # TC: delete 1 and update 1
        provider._client._request.reset_mock()
        provider._client.zone_records = Mock(return_value=[
            {
                "name": "www",
                "ttl": 300,
                "type": "A",
                "resource_records": [{
                    "content": ["1.2.3.4"]
                }],
            },
            {
                "name": "ttl",
                "ttl": 600,
                "type": "A",
                "resource_records": [{
                    "content": ["3.2.3.4"]
                }],
            },
        ])

        # Domain exists, we don't care about return
        resp.json.side_effect = ["{}"]

        wanted = Zone("unit.tests.", [])
        wanted.add_record(
            Record.new(wanted, "ttl", {
                "ttl": 300,
                "type": "A",
                "value": "3.2.3.4"
            }))

        plan = provider.plan(wanted)
        self.assertTrue(plan.exists)
        self.assertEqual(2, len(plan.changes))
        self.assertEqual(2, provider.apply(plan))

        provider._client._request.assert_has_calls([
            call("DELETE", "http://api/zones/unit.tests/www.unit.tests./A"),
            call(
                "PUT",
                "http://api/zones/unit.tests/ttl.unit.tests./A",
                data={
                    "ttl": 300,
                    "resource_records": [{
                        "content": ["3.2.3.4"]
                    }],
                },
            ),
        ])

        # TC: create dynamics
        provider._client._request.reset_mock()
        provider._client.zone_records = Mock(return_value=[])

        # Domain exists, we don't care about return
        resp.json.side_effect = ["{}"]

        wanted = Zone("unit.tests.", [])
        wanted.add_record(
            Record.new(
                wanted,
                "geo-simple",
                {
                    "ttl": 300,
                    "type": "A",
                    "value": "3.3.3.3",
                    "dynamic": {
                        "pools": {
                            "pool-1": {
                                "fallback":
                                "other",
                                "values": [
                                    {
                                        "value": "1.1.1.1"
                                    },
                                    {
                                        "value": "1.1.1.2"
                                    },
                                ],
                            },
                            "pool-2": {
                                "fallback": "other",
                                "values": [
                                    {
                                        "value": "2.2.2.1"
                                    },
                                ],
                            },
                            "other": {
                                "values": [{
                                    "value": "3.3.3.3"
                                }]
                            },
                        },
                        "rules": [
                            {
                                "pool": "pool-1",
                                "geos": ["EU-RU"]
                            },
                            {
                                "pool": "pool-2",
                                "geos": ["EU"]
                            },
                            {
                                "pool": "other"
                            },
                        ],
                    },
                },
            ), )
        wanted.add_record(
            Record.new(
                wanted,
                "geo-defaults",
                {
                    "ttl": 300,
                    "type": "A",
                    "value": "3.2.3.4",
                    "dynamic": {
                        "pools": {
                            "pool-1": {
                                "values": [
                                    {
                                        "value": "2.2.2.1"
                                    },
                                ],
                            },
                        },
                        "rules": [
                            {
                                "pool": "pool-1",
                                "geos": ["EU"]
                            },
                        ],
                    },
                },
            ), )
        wanted.add_record(
            Record.new(
                wanted,
                "cname-smpl",
                {
                    "ttl": 300,
                    "type": "CNAME",
                    "value": "en.unit.tests.",
                    "dynamic": {
                        "pools": {
                            "pool-1": {
                                "fallback":
                                "other",
                                "values": [
                                    {
                                        "value": "ru-1.unit.tests."
                                    },
                                    {
                                        "value": "ru-2.unit.tests."
                                    },
                                ],
                            },
                            "pool-2": {
                                "fallback": "other",
                                "values": [
                                    {
                                        "value": "eu.unit.tests."
                                    },
                                ],
                            },
                            "other": {
                                "values": [{
                                    "value": "en.unit.tests."
                                }]
                            },
                        },
                        "rules": [
                            {
                                "pool": "pool-1",
                                "geos": ["EU-RU"]
                            },
                            {
                                "pool": "pool-2",
                                "geos": ["EU"]
                            },
                            {
                                "pool": "other"
                            },
                        ],
                    },
                },
            ), )
        wanted.add_record(
            Record.new(
                wanted,
                "cname-dflt",
                {
                    "ttl": 300,
                    "type": "CNAME",
                    "value": "en.unit.tests.",
                    "dynamic": {
                        "pools": {
                            "pool-1": {
                                "values": [
                                    {
                                        "value": "eu.unit.tests."
                                    },
                                ],
                            },
                        },
                        "rules": [
                            {
                                "pool": "pool-1",
                                "geos": ["EU"]
                            },
                        ],
                    },
                },
            ), )

        plan = provider.plan(wanted)
        self.assertTrue(plan.exists)
        self.assertEqual(4, len(plan.changes))
        self.assertEqual(4, provider.apply(plan))

        provider._client._request.assert_has_calls([
            call(
                "POST",
                "http://api/zones/unit.tests/geo-simple.unit.tests./A",
                data={
                    "ttl":
                    300,
                    "filters":
                    self.default_filters,
                    "resource_records": [
                        {
                            "content": ["1.1.1.1"],
                            "meta": {
                                "countries": ["RU"]
                            },
                        },
                        {
                            "content": ["1.1.1.2"],
                            "meta": {
                                "countries": ["RU"]
                            },
                        },
                        {
                            "content": ["2.2.2.1"],
                            "meta": {
                                "continents": ["EU"]
                            },
                        },
                        {
                            "content": ["3.3.3.3"],
                            "meta": {
                                "default": True
                            },
                        },
                    ],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/geo-defaults.unit.tests./A",
                data={
                    "ttl":
                    300,
                    "filters":
                    self.default_filters,
                    "resource_records": [
                        {
                            "content": ["2.2.2.1"],
                            "meta": {
                                "continents": ["EU"]
                            },
                        },
                        {
                            "content": ["3.2.3.4"],
                        },
                    ],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/cname-smpl.unit.tests./CNAME",
                data={
                    "ttl":
                    300,
                    "filters":
                    self.default_filters,
                    "resource_records": [
                        {
                            "content": ["ru-1.unit.tests."],
                            "meta": {
                                "countries": ["RU"]
                            },
                        },
                        {
                            "content": ["ru-2.unit.tests."],
                            "meta": {
                                "countries": ["RU"]
                            },
                        },
                        {
                            "content": ["eu.unit.tests."],
                            "meta": {
                                "continents": ["EU"]
                            },
                        },
                        {
                            "content": ["en.unit.tests."],
                            "meta": {
                                "default": True
                            },
                        },
                    ],
                },
            ),
            call(
                "POST",
                "http://api/zones/unit.tests/cname-dflt.unit.tests./CNAME",
                data={
                    "ttl":
                    300,
                    "filters":
                    self.default_filters,
                    "resource_records": [
                        {
                            "content": ["eu.unit.tests."],
                            "meta": {
                                "continents": ["EU"]
                            },
                        },
                        {
                            "content": ["en.unit.tests."],
                        },
                    ],
                },
            ),
        ])
Пример #40
0
    def test_apply(self):
        provider = ConstellixProvider('test', 'api', 'secret')

        resp = Mock()
        resp.json = Mock()
        provider._client._request = Mock(return_value=resp)

        with open('tests/fixtures/constellix-domains.json') as fh:
            domains = json.load(fh)

        # non-existent domain, create everything
        resp.json.side_effect = [
            ConstellixClientNotFound,  # no zone in populate
            ConstellixClientNotFound,  # no domain during apply
            domains
        ]
        plan = provider.plan(self.expected)

        # No root NS, no ignored, no excluded, no unsupported
        n = len(self.expected.records) - 5
        self.assertEquals(n, len(plan.changes))
        self.assertEquals(n, provider.apply(plan))

        provider._client._request.assert_has_calls([
            # created the domain
            call('POST', '/', data={'names': ['unit.tests']}),
            # get all domains to build the cache
            call('GET', '/'),
            call('POST',
                 '/123123/records/SRV',
                 data={
                     'roundRobin': [{
                         'priority': 10,
                         'weight': 20,
                         'value': 'foo-1.unit.tests.',
                         'port': 30
                     }, {
                         'priority': 12,
                         'weight': 20,
                         'value': 'foo-2.unit.tests.',
                         'port': 30
                     }],
                     'name':
                     '_srv._tcp',
                     'ttl':
                     600,
                 }),
        ])

        self.assertEquals(20, provider._client._request.call_count)

        provider._client._request.reset_mock()

        provider._client.records = Mock(
            return_value=[{
                'id': 11189897,
                'type': 'A',
                'name': 'www',
                'ttl': 300,
                'value': [
                    '1.2.3.4',
                    '2.2.3.4',
                ]
            }, {
                'id': 11189898,
                'type': 'A',
                'name': 'ttl',
                'ttl': 600,
                'value': ['3.2.3.4']
            }])

        # Domain exists, we don't care about return
        resp.json.side_effect = ['{}']

        wanted = Zone('unit.tests.', [])
        wanted.add_record(
            Record.new(wanted, 'ttl', {
                'ttl': 300,
                'type': 'A',
                'value': '3.2.3.4'
            }))

        plan = provider.plan(wanted)
        self.assertEquals(2, len(plan.changes))
        self.assertEquals(2, provider.apply(plan))

        # recreate for update, and deletes for the 2 parts of the other
        provider._client._request.assert_has_calls([
            call('POST',
                 '/123123/records/A',
                 data={
                     'roundRobin': [{
                         'value': '3.2.3.4'
                     }],
                     'name': 'ttl',
                     'ttl': 300
                 }),
            call('DELETE', '/123123/records/A/11189897'),
            call('DELETE', '/123123/records/A/11189898')
        ],
                                                   any_order=True)
Пример #41
0
    def test_apply(self):
        provider = DigitalOceanProvider('test', 'token')

        resp = Mock()
        resp.json = Mock()
        provider._client._request = Mock(return_value=resp)

        domain_after_creation = {
            "domain_records": [{
                "id": 11189874,
                "type": "NS",
                "name": "@",
                "data": "ns1.digitalocean.com",
                "priority": None,
                "port": None,
                "ttl": 3600,
                "weight": None,
                "flags": None,
                "tag": None
            }, {
                "id": 11189875,
                "type": "NS",
                "name": "@",
                "data": "ns2.digitalocean.com",
                "priority": None,
                "port": None,
                "ttl": 3600,
                "weight": None,
                "flags": None,
                "tag": None
            }, {
                "id": 11189876,
                "type": "NS",
                "name": "@",
                "data": "ns3.digitalocean.com",
                "priority": None,
                "port": None,
                "ttl": 3600,
                "weight": None,
                "flags": None,
                "tag": None
            }, {
                "id": 11189877,
                "type": "A",
                "name": "@",
                "data": "192.0.2.1",
                "priority": None,
                "port": None,
                "ttl": 3600,
                "weight": None,
                "flags": None,
                "tag": None
            }],
            "links": {},
            "meta": {
                "total": 4
            }
        }

        # non-existent domain, create everything
        resp.json.side_effect = [
            DigitalOceanClientNotFound,  # no zone in populate
            DigitalOceanClientNotFound,  # no domain during apply
            domain_after_creation
        ]
        plan = provider.plan(self.expected)

        # No root NS, no ignored, no excluded, no unsupported
        n = len(self.expected.records) - 7
        self.assertEquals(n, len(plan.changes))
        self.assertEquals(n, provider.apply(plan))
        self.assertFalse(plan.exists)

        provider._client._request.assert_has_calls([
            # created the domain
            call('POST',
                 '/domains',
                 data={
                     'ip_address': '192.0.2.1',
                     'name': 'unit.tests'
                 }),
            # get all records in newly created zone
            call('GET', '/domains/unit.tests/records', {'page': 1}),
            # delete the initial A record
            call('DELETE', '/domains/unit.tests/records/11189877'),
            # created at least one of the record with expected data
            call('POST',
                 '/domains/unit.tests/records',
                 data={
                     'name': '_srv._tcp',
                     'weight': 20,
                     'data': 'foo-1.unit.tests.',
                     'priority': 10,
                     'ttl': 600,
                     'type': 'SRV',
                     'port': 30
                 }),
        ])
        self.assertEquals(24, provider._client._request.call_count)

        provider._client._request.reset_mock()

        # delete 1 and update 1
        provider._client.records = Mock(return_value=[{
            'id': 11189897,
            'name': 'www',
            'data': '1.2.3.4',
            'ttl': 300,
            'type': 'A',
        }, {
            'id': 11189898,
            'name': 'www',
            'data': '2.2.3.4',
            'ttl': 300,
            'type': 'A',
        }, {
            'id': 11189899,
            'name': 'ttl',
            'data': '3.2.3.4',
            'ttl': 600,
            'type': 'A',
        }])

        # Domain exists, we don't care about return
        resp.json.side_effect = ['{}']

        wanted = Zone('unit.tests.', [])
        wanted.add_record(
            Record.new(wanted, 'ttl', {
                'ttl': 300,
                'type': 'A',
                'value': '3.2.3.4'
            }))

        plan = provider.plan(wanted)
        self.assertTrue(plan.exists)
        self.assertEquals(2, len(plan.changes))
        self.assertEquals(2, provider.apply(plan))
        # recreate for update, and delete for the 2 parts of the other
        provider._client._request.assert_has_calls([
            call('POST',
                 '/domains/unit.tests/records',
                 data={
                     'data': '3.2.3.4',
                     'type': 'A',
                     'name': 'ttl',
                     'ttl': 300
                 }),
            call('DELETE', '/domains/unit.tests/records/11189899'),
            call('DELETE', '/domains/unit.tests/records/11189897'),
            call('DELETE', '/domains/unit.tests/records/11189898')
        ],
                                                   any_order=True)
    def test_apply(self):
        provider = EasyDNSProvider('test', 'token', 'apikey')

        resp = Mock()
        resp.json = Mock()
        provider._client._request = Mock(return_value=resp)

        domain_after_creation = {
            "tm":
            1000000000,
            "data": [{
                "id": "12341001",
                "domain": "unit.tests",
                "host": "@",
                "ttl": "0",
                "prio": "0",
                "type": "SOA",
                "rdata": "dns1.easydns.com. zone.easydns.com. 2020010101"
                " 3600 600 604800 0",
                "geozone_id": "0",
                "last_mod": "2020-01-01 01:01:01"
            }, {
                "id": "12341002",
                "domain": "unit.tests",
                "host": "@",
                "ttl": "0",
                "prio": "0",
                "type": "NS",
                "rdata": "LOCAL.",
                "geozone_id": "0",
                "last_mod": "2020-01-01 01:01:01"
            }, {
                "id": "12341003",
                "domain": "unit.tests",
                "host": "@",
                "ttl": "0",
                "prio": "0",
                "type": "MX",
                "rdata": "LOCAL.",
                "geozone_id": "0",
                "last_mod": "2020-01-01 01:01:01"
            }],
            "count":
            3,
            "total":
            3,
            "start":
            0,
            "max":
            1000,
            "status":
            200
        }

        # non-existent domain, create everything
        resp.json.side_effect = [
            EasyDNSClientNotFound,  # no zone in populate
            domain_after_creation
        ]
        plan = provider.plan(self.expected)

        # No root NS, no ignored, no excluded, no unsupported
        n = len(self.expected.records) - 9
        self.assertEquals(n, len(plan.changes))
        self.assertEquals(n, provider.apply(plan))
        self.assertFalse(plan.exists)

        self.assertEquals(25, provider._client._request.call_count)

        provider._client._request.reset_mock()

        # delete 1 and update 1
        provider._client.records = Mock(
            return_value=[{
                "id": "12342001",
                "domain": "unit.tests",
                "host": "www",
                "ttl": "300",
                "prio": "0",
                "type": "A",
                "rdata": "2.2.3.9",
                "geozone_id": "0",
                "last_mod": "2020-01-01 01:01:01"
            }, {
                "id": "12342002",
                "domain": "unit.tests",
                "host": "www",
                "ttl": "300",
                "prio": "0",
                "type": "A",
                "rdata": "2.2.3.8",
                "geozone_id": "0",
                "last_mod": "2020-01-01 01:01:01"
            }, {
                "id": "12342003",
                "domain": "unit.tests",
                "host": "test1",
                "ttl": "3600",
                "prio": "0",
                "type": "A",
                "rdata": "1.2.3.4",
                "geozone_id": "0",
                "last_mod": "2020-01-01 01:01:01"
            }])

        # Domain exists, we don't care about return
        resp.json.side_effect = ['{}']

        wanted = Zone('unit.tests.', [])
        wanted.add_record(
            Record.new(wanted, 'test1', {
                "name": "test1",
                "ttl": 300,
                "type": "A",
                "value": "1.2.3.4",
            }))

        plan = provider.plan(wanted)
        self.assertTrue(plan.exists)
        self.assertEquals(2, len(plan.changes))
        self.assertEquals(2, provider.apply(plan))
        # recreate for update, and delete for the 2 parts of the other
        provider._client._request.assert_has_calls([
            call('PUT',
                 '/zones/records/add/unit.tests/A',
                 data={
                     'rdata': '1.2.3.4',
                     'name': 'test1',
                     'ttl': 300,
                     'type': 'A',
                     'host': 'test1',
                 }),
            call('DELETE', '/zones/records/unit.tests/12342001'),
            call('DELETE', '/zones/records/unit.tests/12342002'),
            call('DELETE', '/zones/records/unit.tests/12342003')
        ],
                                                   any_order=True)
Пример #43
0
def fake_jenkins_response(*args, **kwargs):
    resp = Mock()
    resp.json = json.loads(get_content('jenkins_response.json'))
    resp.status_code = 200
    return resp
Пример #44
0
    def test_apply(self):
        provider = ConstellixProvider('test', 'api', 'secret')

        resp = Mock()
        resp.json = Mock()
        provider._client._request = Mock(return_value=resp)

        # non-existent domain, create everything
        resp.json.side_effect = [
            [],  # no domains returned during populate
            [{
                'id': 123123,
                'name': 'unit.tests'
            }],  # domain created in apply
        ]

        plan = provider.plan(self.expected)

        # No root NS, no ignored, no excluded, no unsupported
        n = len(self.expected.records) - 6
        self.assertEquals(n, len(plan.changes))
        self.assertEquals(n, provider.apply(plan))

        provider._client._request.assert_has_calls([
            # get all domains to build the cache
            call('GET', ''),
            # created the domain
            call('POST', '/', data={'names': ['unit.tests']})
        ])
        # These two checks are broken up so that ordering doesn't break things.
        # Python3 doesn't make the calls in a consistent order so different
        # things follow the GET / on different runs
        provider._client._request.assert_has_calls([
            call('POST',
                 '/123123/records/SRV',
                 data={
                     'roundRobin': [{
                         'priority': 10,
                         'weight': 20,
                         'value': 'foo-1.unit.tests.',
                         'port': 30
                     }, {
                         'priority': 12,
                         'weight': 20,
                         'value': 'foo-2.unit.tests.',
                         'port': 30
                     }],
                     'name':
                     '_srv._tcp',
                     'ttl':
                     600,
                 }),
        ])

        self.assertEquals(17, provider._client._request.call_count)

        provider._client._request.reset_mock()

        provider._client.records = Mock(
            return_value=[{
                'id': 11189897,
                'type': 'A',
                'name': 'www',
                'ttl': 300,
                'value': [
                    '1.2.3.4',
                    '2.2.3.4',
                ]
            }, {
                'id': 11189898,
                'type': 'A',
                'name': 'ttl',
                'ttl': 600,
                'value': ['3.2.3.4']
            }, {
                'id': 11189899,
                'type': 'ALIAS',
                'name': 'alias',
                'ttl': 600,
                'value': [{
                    'value': 'aname.unit.tests.'
                }]
            }])

        # Domain exists, we don't care about return
        resp.json.side_effect = ['{}']

        wanted = Zone('unit.tests.', [])
        wanted.add_record(
            Record.new(wanted, 'ttl', {
                'ttl': 300,
                'type': 'A',
                'value': '3.2.3.4'
            }))

        plan = provider.plan(wanted)
        self.assertEquals(3, len(plan.changes))
        self.assertEquals(3, provider.apply(plan))

        # recreate for update, and deletes for the 2 parts of the other
        provider._client._request.assert_has_calls([
            call('POST',
                 '/123123/records/A',
                 data={
                     'roundRobin': [{
                         'value': '3.2.3.4'
                     }],
                     'name': 'ttl',
                     'ttl': 300
                 }),
            call('DELETE', '/123123/records/A/11189897'),
            call('DELETE', '/123123/records/A/11189898'),
            call('DELETE', '/123123/records/ANAME/11189899')
        ],
                                                   any_order=True)
    def test_apply(self):
        # Create provider with sandbox enabled
        provider = DnsMadeEasyProvider('test', 'api', 'secret', True)

        resp = Mock()
        resp.json = Mock()
        provider._client._request = Mock(return_value=resp)

        with open('tests/fixtures/dnsmadeeasy-domains.json') as fh:
            domains = json.load(fh)

        # non-existent domain, create everything
        resp.json.side_effect = [
            DnsMadeEasyClientNotFound,  # no zone in populate
            DnsMadeEasyClientNotFound,  # no domain during apply
            domains
        ]
        plan = provider.plan(self.expected)

        # No root NS, no ignored, no excluded, no unsupported
        n = len(self.expected.records) - 9
        self.assertEquals(n, len(plan.changes))
        self.assertEquals(n, provider.apply(plan))

        provider._client._request.assert_has_calls([
            # created the domain
            call('POST', '/', data={'name': 'unit.tests'}),
            # get all domains to build the cache
            call('GET', '/'),
            # created at least some of the record with expected data
            call('POST',
                 '/123123/records',
                 data={
                     'type': 'A',
                     'name': '',
                     'value': '1.2.3.4',
                     'ttl': 300
                 }),
            call('POST',
                 '/123123/records',
                 data={
                     'type': 'A',
                     'name': '',
                     'value': '1.2.3.5',
                     'ttl': 300
                 }),
            call('POST',
                 '/123123/records',
                 data={
                     'type': 'ANAME',
                     'name': '',
                     'value': 'aname.unit.tests.',
                     'ttl': 1800
                 }),
            call('POST',
                 '/123123/records',
                 data={
                     'name': '',
                     'value': 'ca.unit.tests',
                     'issuerCritical': 0,
                     'caaType': 'issue',
                     'ttl': 3600,
                     'type': 'CAA'
                 }),
            call('POST',
                 '/123123/records',
                 data={
                     'name': '_srv._tcp',
                     'weight': 20,
                     'value': 'foo-1.unit.tests.',
                     'priority': 10,
                     'ttl': 600,
                     'type': 'SRV',
                     'port': 30
                 }),
        ])
        self.assertEquals(26, provider._client._request.call_count)

        provider._client._request.reset_mock()

        # delete 1 and update 1
        provider._client.records = Mock(return_value=[{
            'id': 11189897,
            'name': 'www',
            'value': '1.2.3.4',
            'ttl': 300,
            'type': 'A',
        }, {
            'id': 11189898,
            'name': 'www',
            'value': '2.2.3.4',
            'ttl': 300,
            'type': 'A',
        }, {
            'id': 11189899,
            'name': 'ttl',
            'value': '3.2.3.4',
            'ttl': 600,
            'type': 'A',
        }])

        # Domain exists, we don't care about return
        resp.json.side_effect = ['{}']

        wanted = Zone('unit.tests.', [])
        wanted.add_record(
            Record.new(wanted, 'ttl', {
                'ttl': 300,
                'type': 'A',
                'value': '3.2.3.4'
            }))

        plan = provider.plan(wanted)
        self.assertEquals(2, len(plan.changes))
        self.assertEquals(2, provider.apply(plan))

        # recreate for update, and deletes for the 2 parts of the other
        provider._client._request.assert_has_calls([
            call('POST',
                 '/123123/records',
                 data={
                     'value': '3.2.3.4',
                     'type': 'A',
                     'name': 'ttl',
                     'ttl': 300
                 }),
            call('DELETE', '/123123/records/11189899'),
            call('DELETE', '/123123/records/11189897'),
            call('DELETE', '/123123/records/11189898')
        ],
                                                   any_order=True)