def test_connect_zone(mocked_responses, vinyldns_client):
mocked_responses.add(responses.POST,
'http://test.com/zones',
body=to_json_string(sample_zone_change),
status=200)
r = vinyldns_client.connect_zone(forward_zone)
check_zones_are_same(forward_zone, r.zone)
def test_list_zone_changes(mocked_responses, vinyldns_client):
change1 = ZoneChange(zone=forward_zone,
user_id='some-user',
change_type='Create',
status='Pending',
created=datetime.utcnow(),
system_message=None,
id='zone-change-id1')
change2 = ZoneChange(zone=ip4_zone,
user_id='some-user',
change_type='Create',
status='Pending',
created=datetime.utcnow(),
system_message='msg',
id='zone-change-id2')
lzcr = ListZoneChangesResponse(forward_zone.id, [change1, change2], 'next',
'start', 100)
mocked_responses.add(
responses.GET,
'http://test.com/zones/{0}/changes?startFrom=start&maxItems=100'.
format(forward_zone.id),
body=to_json_string(lzcr),
status=200)
r = vinyldns_client.list_zone_changes(forward_zone.id, 'start', 100)
assert r.start_from == lzcr.start_from
assert r.next_id == lzcr.next_id
assert r.max_items == lzcr.max_items
for l, r in zip(lzcr.zone_changes, r.zone_changes):
assert l.id == r.id
assert l.user_id == r.user_id
assert l.change_type == r.change_type
assert l.status == r.status
assert l.created == r.created
assert l.system_message == r.system_message
check_zones_are_same(l.zone, r.zone)
def test_cancel_batch_change(mocked_responses, vinyldns_client):
error_message = (
"Zone Discovery Failed: zone for 'foo.bar.com' does not exist in"
" VinylDNS. If zone exists, then it must be connected to in VinylDNS.")
error = ValidationError('ZoneDiscoveryError', error_message)
arc = AddRecordChange(forward_zone.id, forward_zone.name,
'cancel', 'cancel.bar.com', RecordType.A, 200,
AData('1.2.3.4'), 'PendingReview', 'id1', [error],
'system-message', 'cchangeid1', 'csid1')
drc = DeleteRecordSetChange(forward_zone.id, forward_zone.name, 'cancel2',
'cancel2.bar.com', RecordType.A, 'Complete',
'id2', [], 'system-message', 'cchangeid2',
'csid2')
bc = BatchChange('user-id',
'user-name',
datetime.utcnow(), [arc, drc],
'bcid',
'Cancelled',
'Cancelled',
owner_group_id='owner-group-id')
mocked_responses.add(
responses.POST,
'http://test.com/zones/batchrecordchanges/bcid/cancel',
body=to_json_string(bc),
status=200)
c = vinyldns_client.cancel_batch_change('bcid')
check_batch_changes_are_same(c, bc)
def test_abandon_zone(mocked_responses, vinyldns_client):
mocked_responses.add(responses.DELETE,
'http://test.com/zones/{0}'.format(forward_zone.id),
body=to_json_string(sample_zone_change),
status=200)
r = vinyldns_client.abandon_zone(forward_zone.id)
check_zones_are_same(forward_zone, r.zone)
def test_approve_batch_change(mocked_responses, vinyldns_client):
arc = AddRecordChange(forward_zone.id, forward_zone.name,
'foo', 'foo.bar.com', RecordType.A, 200,
AData('1.2.3.4'), 'PendingReview', 'id1', [],
'system-message', 'rchangeid1', 'rsid1')
drc = DeleteRecordSetChange(forward_zone.id, forward_zone.name, 'baz',
'baz.bar.com', RecordType.A, 'PendingReview',
'id2', [], 'system-message', 'rchangeid2',
'rsid2')
bc = BatchChange('user-id',
'user-name',
datetime.utcnow(), [arc, drc],
'bcid',
'Complete',
'ManuallyApproved',
comments='batch change test',
owner_group_id='owner-group-id',
reviewer_id='admin-id',
reviewer_user_name='admin',
review_comment='looks good',
review_timestamp=datetime.utcnow())
mocked_responses.add(
responses.POST,
'http://test.com/zones/batchrecordchanges/bcid/approve',
body=to_json_string(bc),
status=200)
r = vinyldns_client.approve_batch_change('bcid', 'looks good')
check_batch_changes_are_same(r, bc)
def test_get_batch_change(mocked_responses, vinyldns_client):
arc = AddRecordChange(forward_zone.id, forward_zone.name,
'foo', 'foo.bar.com', RecordType.A, 200,
AData('1.2.3.4'), 'Complete', 'id1', [],
'system-message', 'rchangeid1', 'rsid1')
drc = DeleteRecordSetChange(forward_zone.id, forward_zone.name, 'baz',
'baz.bar.com', RecordType.A, 'Complete', 'id2',
[], 'system-message', 'rchangeid2', 'rsid2')
drc_with_data = DeleteRecordSetChange(forward_zone.id, forward_zone.name,
'biz', 'biz.bar.com', RecordType.A,
'Complete', 'id3', [],
'system-message', 'rchangeid3',
'rsid3', AData("5.6.7.8"))
bc = BatchChange('user-id',
'user-name',
datetime.utcnow(), [arc, drc, drc_with_data],
'bcid',
'Complete',
'AutoApproved',
comments='batch change test',
owner_group_id='owner-group-id')
mocked_responses.add(responses.GET,
'http://test.com/zones/batchrecordchanges/bcid',
body=to_json_string(bc),
status=200)
r = vinyldns_client.get_batch_change('bcid')
check_batch_changes_are_same(r, bc)
def test_create_batch_change(mocked_responses, vinyldns_client):
ar = AddRecord('foo.bar.com', RecordType.A, 100, '1.2.3.4')
drs = DeleteRecordSet('baz.bar.com', RecordType.A)
arc = AddRecordChange(forward_zone.id, forward_zone.name, 'foo', 'foo.bar.com', RecordType.A, '1.2.3.4',
'Complete', 'id1', 'system-message', 'rchangeid1', 'rsid1')
drc = DeleteRecordSetChange(forward_zone.id, forward_zone.name, 'baz', 'baz.bar.com', RecordType.A, 'Complete',
'id2', 'system-message', 'rchangeid2', 'rsid2')
bc = BatchChange('user-id', 'user-name', 'batch change test', datetime.utcnow(), [arc, drc], 'bcid')
mocked_responses.add(
responses.POST, 'http://test.com/zones/batchrecordchanges',
body=to_json_string(bc), status=200
)
r = vinyldns_client.create_batch_change(
BatchChangeRequest(
changes=[ar, drs],
comments='batch change test'
))
assert r.user_id == bc.user_id
assert r.user_name == bc.user_name
assert r.comments == bc.comments
assert r.created_timestamp == bc.created_timestamp
assert r.id == bc.id
for l, r in zip(r.changes, bc.changes):
check_single_changes_are_same(l, r)
def test_get_zone(mocked_responses, vinyldns_client):
mocked_responses.add(responses.GET,
'http://test.com/zones/{0}'.format(forward_zone.id),
body=to_json_string({'zone': forward_zone}),
status=200)
r = vinyldns_client.get_zone(forward_zone.id)
check_zones_are_same(forward_zone, r)
def test_delete_acl_rule(mocked_responses, vinyldns_client):
mocked_responses.add(responses.DELETE,
'http://test.com/zones/{0}/acl/rules'.format(
forward_zone.id),
body=to_json_string(sample_zone_change))
r = vinyldns_client.delete_zone_acl_rule(forward_zone.id, acl_rule)
check_zones_are_same(r.zone, sample_zone_change.zone)
def test_zone_serdes():
s = to_json_string(forward_zone)
print(json.dumps(s, indent=4))
z = from_json_string(s, Zone.from_dict)
assert z.name == forward_zone.name
assert z.connection.primary_server == forward_zone.connection.primary_server
assert all([a.__dict__ == b.__dict__ for a, b in zip(z.acl.rules, forward_zone.acl.rules)])
def create_batch_change(self, batch_change_input, **kwargs):
"""
Create a new batch change.
:param batch_change_input: the batchchange to be created
:return: the content of the response
"""
url = urljoin(self.index_url, u'/zones/batchrecordchanges')
response, data = self.__make_request(url, u'POST', self.headers, to_json_string(batch_change_input), **kwargs)
return BatchChange.from_dict(data)
def update_zone(self, zone, **kwargs):
"""
Update a zone.
:param zone: the zone to be created
:return: the content of the response
"""
url = urljoin(self.index_url, u'/zones/{0}'.format(zone.id))
response, data = self.__make_request(url, u'PUT', self.headers, to_json_string(zone), **kwargs)
return ZoneChange.from_dict(data)
def test_create_record_set(record_set, mocked_responses, vinyldns_client):
change = gen_rs_change(record_set)
mocked_responses.add(responses.POST,
'http://test.com/zones/{0}/recordsets'.format(
record_set.zone_id),
body=to_json_string(change),
status=200)
r = vinyldns_client.create_record_set(record_set)
check_record_set_changes_are_equal(change, r)
mocked_responses.reset()
def create_record_set(self, record_set, **kwargs):
"""
Create a new record_set.
:param record_set: the record_set to be created
:return: the content of the response
"""
url = urljoin(self.index_url, u'/zones/{0}/recordsets'.format(record_set.zone_id))
response, data = self.__make_request(url, u'POST', self.headers, to_json_string(record_set), **kwargs)
return RecordSetChange.from_dict(data)
def connect_zone(self, zone, **kwargs):
"""
Create a new zone with the given name and email.
:param zone: the zone to be created
:return: the content of the response
"""
url = urljoin(self.index_url, u'/zones')
response, data = self.__make_request(url, u'POST', self.headers, to_json_string(zone), **kwargs)
return ZoneChange.from_dict(data)
def update_group(self, group, **kwargs):
"""
Update an existing group, uses the id of the group provided
:param group: A group to be updated
:return: the content of the response, which should be a group json
"""
url = urljoin(self.index_url, u'/groups/{0}'.format(group.id))
response, data = self.__make_request(url, u'PUT', self.headers, to_json_string(group), **kwargs)
return Group.from_dict(data)
def create_group(self, group, **kwargs):
"""
Create a new group.
:param group: A group dictionary that can be serialized to json
:return: the content of the response, which should be a group json
"""
url = urljoin(self.index_url, u'/groups')
response, data = self.__make_request(url, u'POST', self.headers, to_json_string(group), **kwargs)
return Group.from_dict(data)
def test_get_record_set(record_set, mocked_responses, vinyldns_client):
rs = copy.deepcopy(record_set)
rs.id = rs.name + 'id'
mocked_responses.add(responses.GET,
'http://test.com/zones/{0}/recordsets/{1}'.format(
rs.zone_id, rs.id),
body=to_json_string(rs),
status=200)
r = vinyldns_client.get_record_set(rs.zone_id, rs.id)
check_record_sets_are_equal(rs, r)
mocked_responses.reset()
def test_get_record_set_change(record_set, mocked_responses, vinyldns_client):
change = gen_rs_change(record_set)
mocked_responses.add(
responses.GET,
'http://test.com/zones/{0}/recordsets/{1}/changes/{2}'.format(
record_set.zone_id, record_set.id, change.id),
body=to_json_string(change),
status=200)
r = vinyldns_client.get_record_set_change(record_set.zone_id,
record_set.id, change.id)
check_record_set_changes_are_equal(r, change)
def test_sync_zone(mocked_responses, vinyldns_client):
mocked_responses.add(
responses.POST, 'http://test.com/zones/{0}/sync'.format(forward_zone.id),
body=to_json_string(sample_zone_change), status=200)
r = vinyldns_client.sync_zone(forward_zone.id)
assert sample_zone_change.id == r.id
assert sample_zone_change.change_type == r.change_type
assert sample_zone_change.status == r.status
assert sample_zone_change.system_message == r.system_message
assert sample_zone_change.user_id == r.user_id
check_zones_are_same(forward_zone, r.zone)
def approve_batch_change(self, batch_change_id, approval=None, **kwargs):
"""
Approve a batch change
:return: the content of the response
"""
url = urljoin(self.index_url, '/zones/batchrecordchanges/{0}/approve'.format(batch_change_id),
to_json_string(approval))
response, data = self.__make_request(url, u'POST', self.headers, to_review_json(approval), **kwargs)
return BatchChange.from_dict(data)
def test_delete_record_set(record_set, mocked_responses, vinyldns_client):
rs = copy.deepcopy(record_set)
rs.id = rs.name + 'id'
change = gen_rs_change(rs)
mocked_responses.add(responses.DELETE,
'http://test.com/zones/{0}/recordsets/{1}'.format(
rs.zone_id, rs.id),
body=to_json_string(change),
status=200)
r = vinyldns_client.delete_record_set(rs.zone_id, rs.id)
check_record_set_changes_are_equal(change, r)
mocked_responses.reset()
def test_list_my_groups(mocked_responses, vinyldns_client):
sample_list_groups = ListGroupsResponse([sample_group, sample_group2], 5, '*', 'start-from', 'next-id')
mocked_responses.add(
responses.GET, 'http://test.com/groups?groupNameFilter=*&startFrom=start-from&maxItems=5',
body=to_json_string(sample_list_groups), status=200)
r = vinyldns_client.list_my_groups('*', 'start-from', 5)
assert sample_list_groups.start_from == r.start_from
assert sample_list_groups.group_name_filter == r.group_name_filter
assert sample_list_groups.next_id == r.next_id
for l, r in zip(sample_list_groups.groups, r.groups):
check_groups_are_same(l, r)
def test_list_all_my_groups(mocked_responses, vinyldns_client):
sample_list_groups1 = ListGroupsResponse([sample_group], 1, '*', 'start-from', 'next-id')
# Set next id to None to indicate end of list
sample_list_groups2 = ListGroupsResponse([sample_group2], 1, '*', 'start-from', next_id=None)
mocked_responses.add(
responses.GET, 'http://test.com/groups?groupNameFilter=*',
body=to_json_string(sample_list_groups1), status=200)
# list all puts the next id from the first response into the startFrom for the next request
mocked_responses.add(
responses.GET, 'http://test.com/groups?groupNameFilter=*&startFrom=next-id',
body=to_json_string(sample_list_groups2), status=200)
r = vinyldns_client.list_all_my_groups('*')
assert r.start_from is None
assert r.next_id is None
assert sample_list_groups1.group_name_filter == r.group_name_filter
for l, r in zip([sample_group, sample_group2], r.groups):
check_groups_are_same(l, r)
def delete_zone_acl_rule(self, zone_id, acl_rule, **kwargs):
"""
Delete an acl rule from the zone.
:param zone_id: The id of the zone to remove the acl from
:param acl_rule: The acl rule to remove
:return: the content of the response
"""
url = urljoin(self.index_url, '/zones/{0}/acl/rules'.format(zone_id))
response, data = self.__make_request(url, 'DELETE', self.headers,
to_json_string(acl_rule), **kwargs)
return ZoneChange.from_dict(data)
def add_zone_acl_rule(self, zone_id, acl_rule, **kwargs):
"""
Put an acl rule on the zone.
:param zone_id: The id of the zone to attach the acl rule to
:param acl_rule: The acl rule contents
:return: the content of the response
"""
url = urljoin(self.index_url, '/zones/{0}/acl/rules'.format(zone_id))
response, data = self.__make_request(url, 'PUT', self.headers,
to_json_string(acl_rule), **kwargs)
return ZoneChange.from_dict(data)
def test_create_batch_change(mocked_responses, vinyldns_client):
ar = AddRecord('foo.baa.com', RecordType.A, 100, AData('1.2.3.4'))
drs = DeleteRecordSet('baz.bar.com', RecordType.A)
drs_with_data = DeleteRecordSet('baz-with-data.bar.com', RecordType.A,
AData('5.6.7.8'))
arc = AddRecordChange(forward_zone.id, forward_zone.name,
'foo', 'foo.bar.com', RecordType.A, 200,
AData('1.2.3.4'), 'Complete', 'id1', [],
'system-message', 'rchangeid1', 'rsid1')
drc = DeleteRecordSetChange(forward_zone.id, forward_zone.name, 'baz',
'baz.bar.com', RecordType.A, 'Complete', 'id2',
[], 'system-message', 'rchangeid2', 'rsid2')
drc_with_data = DeleteRecordSetChange(forward_zone.id, forward_zone.name,
'baz-with-data',
'baz-with-data.bar.com',
RecordType.A, 'Complete', 'id2', [],
'system-message', 'rchangeid3',
'rsid3', AData('5.6.7.8'))
# Python 2/3 compatibility
try:
tomorrow = datetime.now().astimezone() + timedelta(1)
except TypeError:
tomorrow = datetime.now(tzlocal()).astimezone(tzlocal()) + timedelta(1)
bc = BatchChange('user-id',
'user-name',
datetime.utcnow(), [arc, drc, drc_with_data],
'bcid',
'Scheduled',
'PendingReview',
comments='batch change test',
owner_group_id='owner-group-id',
scheduled_time=tomorrow)
mocked_responses.add(responses.POST,
'http://test.com/zones/batchrecordchanges',
body=to_json_string(bc),
status=200)
r = vinyldns_client.create_batch_change(
BatchChangeRequest(changes=[ar, drs, drs_with_data],
comments='batch change test',
owner_group_id='owner-group-id',
scheduled_time=tomorrow))
check_batch_changes_are_same(r, bc)
def test_list_zones(mocked_responses, vinyldns_client):
lzr = ListZonesResponse(zones=[forward_zone, ip4_zone, ip6_zone], name_filter='*', start_from='start-from',
next_id='next', max_items=100)
mocked_responses.add(
responses.GET, 'http://test.com/zones?nameFilter=*&startFrom=start-from&maxItems=100',
body=to_json_string(lzr), status=200
)
r = vinyldns_client.list_zones('*', 'start-from', 100)
assert r.name_filter == lzr.name_filter
assert r.start_from == lzr.start_from
assert r.next_id == lzr.next_id
assert r.max_items == lzr.max_items
for l, r in zip(lzr.zones, r.zones):
check_zones_are_same(l, r)
def test_list_record_sets(mocked_responses, vinyldns_client):
lrr = ListRecordSetsResponse(record_set_values, 'start', 'next', 100, '*')
mocked_responses.add(
responses.GET,
'http://test.com/zones/{0}/recordsets?startFrom=start&maxItems=100&recordNameFilter=*'
.format(forward_zone.id),
body=to_json_string(lrr),
status=200)
r = vinyldns_client.list_record_sets(forward_zone.id, 'start', 100, '*')
assert r.start_from == lrr.start_from
assert r.next_id == lrr.next_id
assert r.record_name_filter == lrr.record_name_filter
assert r.max_items == lrr.max_items
for l, r in zip(r.record_sets, lrr.record_sets):
check_record_sets_are_equal(l, r)
def test_record_set_changes_serdes(record_set):
a = gen_rs_change(record_set)
s = to_json_string(a)
b = from_json_string(s, RecordSetChange.from_dict)
assert a.user_id == b.user_id
assert a.change_type == b.change_type
assert a.status == b.status
assert a.created == b.created
assert a.system_message == b.system_message
assert a.id == b.id
assert a.user_name == b.user_name
assert a.zone.id == b.zone.id
check_record_sets_are_equal(a.record_set, b.record_set)
check_record_sets_are_equal(a.updates, b.updates)
