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__()
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
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)
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' })
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
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')
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
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")
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)
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
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)
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
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
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]
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
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
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)
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)
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)
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
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
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')
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')
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)
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)
def mock_transaction_lookup(transaction_id): m = Mock(status_code=200) m.json = mock_json return m
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
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)
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
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
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."], }, ], }, ), ])
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)
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)
def fake_jenkins_response(*args, **kwargs): resp = Mock() resp.json = json.loads(get_content('jenkins_response.json')) resp.status_code = 200 return resp
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)