/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.globo.globodns.cloudstack.resource;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.any;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.annotation.DirtiesContext.ClassMode;
import com.cloud.agent.api.Answer;
import com.globo.globodns.client.GloboDns;
import com.globo.globodns.client.api.DomainAPI;
import com.globo.globodns.client.api.ExportAPI;
import com.globo.globodns.client.api.RecordAPI;
import com.globo.globodns.client.model.Domain;
import com.globo.globodns.client.model.Record;
import com.globo.globodns.cloudstack.commands.CreateOrUpdateDomainCommand;
import com.globo.globodns.cloudstack.commands.CreateOrUpdateRecordAndReverseCommand;
import com.globo.globodns.cloudstack.commands.RemoveDomainCommand;
import com.globo.globodns.cloudstack.commands.RemoveRecordCommand;
@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
public class GloboDnsResourceTest {
private GloboDnsResource _globoDnsResource;
private GloboDns _globoDnsApi;
private DomainAPI _domainApi;
private RecordAPI _recordApi;
private ExportAPI _exportApi;
private static final Long TEMPLATE_ID = 1l;
private static long sequenceId = 10l;
@Before
public void setUp() throws Exception {
String name = "GloboDNS";
Map<String, Object> params = new HashMap<String, Object>();
params.put("zoneId", "1");
params.put("guid", "globodns");
params.put("name", name);
params.put("url", "http://example.com");
params.put("username", "username");
params.put("password", "password");
_globoDnsResource = new GloboDnsResource();
_globoDnsResource.configure(name, params);
_globoDnsApi = spy(_globoDnsResource._globoDns);
_globoDnsResource._globoDns = _globoDnsApi;
_domainApi = mock(DomainAPI.class);
when(_globoDnsApi.getDomainAPI()).thenReturn(_domainApi);
_recordApi = mock(RecordAPI.class);
when(_globoDnsApi.getRecordAPI()).thenReturn(_recordApi);
_exportApi = mock(ExportAPI.class);
when(_globoDnsApi.getExportAPI()).thenReturn(_exportApi);
}
@After
public void tearDown() throws Exception {
}
///////////////////////
// Auxiliary Methods //
///////////////////////
private Domain generateFakeDomain(String domainName, boolean reverse) {
Domain domain = new Domain();
domain.getDomainAttributes().setId(sequenceId++);
domain.getDomainAttributes().setName(domainName);
List<Domain> domainList = new ArrayList<Domain>();
domainList.add(domain);
if (reverse) {
when(_domainApi.listReverseByQuery(eq(domainName))).thenReturn(domainList);
} else {
when(_domainApi.listByQuery(eq(domainName))).thenReturn(domainList);
}
return domain;
}
private Record generateFakeRecord(Domain domain, String recordName, String recordContent, boolean reverse) {
Record record = new Record();
if (reverse) {
record.getTypePTRRecordAttributes().setName(recordName);
record.getTypePTRRecordAttributes().setContent(recordContent);
record.getTypePTRRecordAttributes().setDomainId(domain.getId());
record.getTypePTRRecordAttributes().setId(sequenceId++);
} else {
record.getTypeARecordAttributes().setName(recordName);
record.getTypeARecordAttributes().setContent(recordContent);
record.getTypeARecordAttributes().setDomainId(domain.getId());
record.getTypeARecordAttributes().setId(sequenceId++);
}
List<Record> recordList = new ArrayList<Record>();
recordList.add(record);
when(_recordApi.listByQuery(eq(domain.getId()), eq(recordName))).thenReturn(recordList);
return record;
}
/////////////////////////
// Create Domain tests //
/////////////////////////
@Test
public void testCreateDomainWithSuccessWhenDomainDoesntExistAndOverrideIsTrue() throws Exception {
String domainName = "domain.name.com";
Domain domain = new Domain();
domain.getDomainAttributes().setId(sequenceId++);
domain.getDomainAttributes().setName(domainName);
when(_domainApi.createDomain(eq(domain.getName()), eq(TEMPLATE_ID), eq("M"))).thenReturn(domain);
Answer answer = _globoDnsResource.execute(new CreateOrUpdateDomainCommand(domainName, TEMPLATE_ID));
assertNotNull(answer);
assertEquals(true, answer.getResult());
verify(_exportApi, times(1)).scheduleExport();
}
@Test
@SuppressWarnings("unused")
public void testCreateDomainWillSucceedWhenDomainAlreadyExistsAndOverrideIsFalse() throws Exception {
String domainName = "domain.name.com";
Domain domain = generateFakeDomain(domainName, false);
Answer answer = _globoDnsResource.execute(new CreateOrUpdateDomainCommand(domainName, TEMPLATE_ID));
assertNotNull(answer);
assertEquals(true, answer.getResult());
}
/////////////////////////
// Create Record tests //
/////////////////////////
@Test
@SuppressWarnings("unused")
public void testCreateRecordAndReverseWithSuccessWhenDomainExistsAndRecordDoesntExistAndOverrideIsTrue() throws Exception {
String recordName = "recordname";
String recordIp = "40.30.20.10";
String domainName = "domain.name.com";
String reverseDomainName = "20.30.40.in-addr.arpa";
String reverseRecordName = "10";
String reverseRecordContent = recordName + "." + domainName;
Domain domain = generateFakeDomain(domainName, false);
Record record = generateFakeRecord(domain, recordName, recordIp, false);
Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, reverseRecordContent, true);
when(_recordApi.createRecord(eq(domain.getId()), eq(recordName), eq(recordIp), eq("A"))).thenReturn(record);
when(_recordApi.createRecord(eq(reverseDomain.getId()), eq(reverseRecordName), eq(reverseRecordContent), eq("PTR"))).thenReturn(record);
Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, recordIp, domainName, TEMPLATE_ID, true));
assertNotNull(answer);
assertEquals(true, answer.getResult());
verify(_exportApi, times(1)).scheduleExport();
}
@Test
@SuppressWarnings("unused")
public void testCreateRecordAndReverseWillFailWhenRecordAlreadyExistsAndOverrideIsFalse() throws Exception {
String recordName = "recordname";
String newIp = "40.30.20.10";
String oldIp = "50.40.30.20";
String domainName = "domain.name.com";
Domain domain = generateFakeDomain(domainName, false);
Record record = generateFakeRecord(domain, recordName, oldIp, false);
Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, newIp, domainName, TEMPLATE_ID, false));
assertNotNull(answer);
assertEquals(false, answer.getResult());
}
@Test
@SuppressWarnings("unused")
public void testCreateRecordAndReverseWillFailWhenReverseRecordAlreadyExistsAndOverrideIsFalse() throws Exception {
String recordName = "recordname";
String recordIp = "40.30.20.10";
String domainName = "domain.name.com";
String reverseDomainName = "20.30.40.in-addr.arpa";
String reverseRecordName = "10";
Domain domain = generateFakeDomain(domainName, false);
Record record = generateFakeRecord(domain, recordName, recordIp, false);
Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, "X", true);
Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, recordIp, domainName, TEMPLATE_ID, false));
assertNotNull(answer);
assertEquals(false, answer.getResult());
}
@Test
public void testCreateRecordAndReverseWhenDomainDoesNotExist() throws Exception {
String recordName = "recordname";
String recordIp = "40.30.20.10";
String domainName = "domain.name.com";
String reverseDomainName = "20.30.40.in-addr.arpa";
String reverseRecordName = "10";
String reverseRecordContent = recordName + "." + domainName;
Domain domain = new Domain();
domain.getDomainAttributes().setId(sequenceId++);
Domain reverseDomain = new Domain();
reverseDomain.getDomainAttributes().setId(sequenceId++);
Record record = new Record();
when(_domainApi.listByQuery(domainName)).thenReturn(new ArrayList<Domain>());
when(_domainApi.createDomain(eq(domainName), eq(TEMPLATE_ID), eq("M"))).thenReturn(domain);
when(_recordApi.createRecord(eq(domain.getId()), eq(recordName), eq(recordIp), eq("A"))).thenReturn(record);
when(_domainApi.createReverseDomain(eq(reverseDomainName), eq(TEMPLATE_ID), eq("M"))).thenReturn(reverseDomain);
when(_recordApi.createRecord(eq(reverseDomain.getId()), eq(reverseRecordName), eq(reverseRecordContent), eq("PTR"))).thenReturn(record);
Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, recordIp, domainName, TEMPLATE_ID, true));
assertNotNull(answer);
assertEquals(true, answer.getResult());
verify(_exportApi, times(1)).scheduleExport();
}
@Test
public void testCreateRecordAndReverseWhenDomainDoesNotExistAndOverrideIsFalse() throws Exception {
String recordName = "recordname";
String recordIp = "40.30.20.10";
String domainName = "domain.name.com";
String reverseDomainName = "20.30.40.in-addr.arpa";
String reverseRecordName = "10";
String reverseRecordContent = recordName + "." + domainName;
Domain domain = new Domain();
domain.getDomainAttributes().setId(sequenceId++);
Domain reverseDomain = new Domain();
reverseDomain.getDomainAttributes().setId(sequenceId++);
Record record = new Record();
when(_domainApi.listByQuery(domainName)).thenReturn(new ArrayList<Domain>());
when(_domainApi.createDomain(eq(domainName), eq(TEMPLATE_ID), eq("M"))).thenReturn(domain);
when(_recordApi.createRecord(eq(domain.getId()), eq(recordName), eq(recordIp), eq("A"))).thenReturn(record);
when(_domainApi.createReverseDomain(eq(reverseDomainName), eq(TEMPLATE_ID), eq("M"))).thenReturn(reverseDomain);
when(_recordApi.createRecord(eq(reverseDomain.getId()), eq(reverseRecordName), eq(reverseRecordContent), eq("PTR"))).thenReturn(record);
Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, recordIp, domainName, TEMPLATE_ID, false));
assertNotNull(answer);
assertEquals(true, answer.getResult());
verify(_exportApi, times(1)).scheduleExport();
}
/////////////////////////
// Update Record tests //
/////////////////////////
@Test
public void testUpdateRecordAndReverseWhenDomainExistsAndOverrideIsTrue() throws Exception {
String recordName = "recordname";
String oldRecordIp = "40.30.20.10";
String newRecordIp = "50.40.30.20";
String domainName = "domain.name.com";
String reverseDomainName = "30.40.50.in-addr.arpa";
String reverseRecordName = "20";
String reverseRecordContent = recordName + "." + domainName;
Domain domain = generateFakeDomain(domainName, false);
Record record = generateFakeRecord(domain, recordName, oldRecordIp, false);
Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, "X", true);
Answer answer = _globoDnsResource.execute(new CreateOrUpdateRecordAndReverseCommand(recordName, newRecordIp, domainName, TEMPLATE_ID, true));
// ensure calls in sequence to ensure this call are the only ones.
InOrder inOrder = inOrder(_recordApi);
inOrder.verify(_recordApi, times(1)).updateRecord(eq(record.getId()), eq(domain.getId()), eq(recordName), eq(newRecordIp));
inOrder.verify(_recordApi, times(1)).updateRecord(eq(reverseRecord.getId()), eq(reverseDomain.getId()), eq(reverseRecordName), eq(reverseRecordContent));
assertNotNull(answer);
assertEquals(true, answer.getResult());
verify(_exportApi, times(1)).scheduleExport();
}
/////////////////////////
// Remove Record tests //
/////////////////////////
@Test
public void testRemoveRecordWhenRecordExists() throws Exception {
String recordName = "recordname";
String recordIp = "40.30.20.10";
String domainName = "domain.name.com";
String reverseDomainName = "20.30.40.in-addr.arpa";
String reverseRecordName = "10";
String reverseRecordContent = recordName + "." + domainName;
Domain domain = generateFakeDomain(domainName, false);
Record record = generateFakeRecord(domain, recordName, recordIp, false);
Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, reverseRecordContent, true);
Answer answer = _globoDnsResource.execute(new RemoveRecordCommand(recordName, recordIp, domainName, true));
assertNotNull(answer);
assertEquals(true, answer.getResult());
verify(_recordApi, times(1)).removeRecord(eq(record.getId()));
verify(_recordApi, times(1)).removeRecord(eq(reverseRecord.getId()));
verify(_exportApi, times(1)).scheduleExport();
}
@Test
public void testRemoveRecordWithSuccessAndReverseRecordNotRemovedWhenReverseRecordExistsWithDifferentValueAndOverrideIsFalse() throws Exception {
String recordName = "recordname";
String recordIp = "40.30.20.10";
String domainName = "domain.name.com";
String reverseDomainName = "20.30.40.in-addr.arpa";
String reverseRecordName = "10";
Domain domain = generateFakeDomain(domainName, false);
Record record = generateFakeRecord(domain, recordName, recordIp, false);
Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, "X", true);
Answer answer = _globoDnsResource.execute(new RemoveRecordCommand(recordName, recordIp, domainName, false));
assertEquals(true, answer.getResult());
verify(_recordApi, times(1)).removeRecord(eq(record.getId()));
verify(_recordApi, never()).removeRecord(eq(reverseRecord.getId()));
verify(_exportApi, times(1)).scheduleExport();
}
@Test
public void testRemoveReverseRecordButNotRemoveRecordWhenRecordExistsWithDifferentValueAndOverrideIsFalse() throws Exception {
String recordName = "recordname";
String recordIp = "40.30.20.10";
String domainName = "domain.name.com";
String reverseDomainName = "20.30.40.in-addr.arpa";
String reverseRecordName = "10";
String reverseRecordContent = recordName + "." + domainName;
Domain domain = generateFakeDomain(domainName, false);
Record record = generateFakeRecord(domain, recordName, "X", false);
Domain reverseDomain = generateFakeDomain(reverseDomainName, true);
Record reverseRecord = generateFakeRecord(reverseDomain, reverseRecordName, reverseRecordContent, true);
Answer answer = _globoDnsResource.execute(new RemoveRecordCommand(recordName, recordIp, domainName, false));
assertEquals(true, answer.getResult());
verify(_recordApi, never()).removeRecord(eq(record.getId()));
verify(_recordApi, times(1)).removeRecord(eq(reverseRecord.getId()));
verify(_exportApi, times(1)).scheduleExport();
}
/////////////////////////
// Remove Domain tests //
/////////////////////////
@Test
public void testRemoveDomainWithSuccessButDomainKeptWhenDomainExistsAndThereAreRecordsAndOverrideIsFalse() throws Exception {
String recordName = "recordname";
String recordIp = "40.30.20.10";
String domainName = "domain.name.com";
Domain domain = generateFakeDomain(domainName, false);
Record record = generateFakeRecord(domain, recordName, "X", false);
when(_recordApi.listAll(domain.getId())).thenReturn(Arrays.asList(record));
Answer answer = _globoDnsResource.execute(new RemoveRecordCommand(recordName, recordIp, domainName, false));
assertEquals(true, answer.getResult());
verify(_domainApi, never()).removeDomain(any(Long.class));
verify(_exportApi, never()).scheduleExport();
}
@Test
public void testRemoveDomainWithSuccessWhenDomainExistsAndThereAreOnlyNSRecordsAndOverrideIsFalse() throws Exception {
String domainName = "domain.name.com";
Domain domain = generateFakeDomain(domainName, false);
List<Record> recordList = new ArrayList<Record>();
for (int i = 0; i < 10; i++) {
Record record = new Record();
record.getTypeNSRecordAttributes().setDomainId(domain.getId());
record.getTypeNSRecordAttributes().setId(sequenceId++);
record.getTypeNSRecordAttributes().setType("NS");
recordList.add(record);
}
when(_recordApi.listAll(domain.getId())).thenReturn(recordList);
Answer answer = _globoDnsResource.execute(new RemoveDomainCommand(domainName, false));
assertEquals(true, answer.getResult());
verify(_domainApi, times(1)).removeDomain(eq(domain.getId()));
verify(_exportApi, times(1)).scheduleExport();
}
@Test
public void testRemoveDomainWithSuccessWhenDomainExistsAndThereAreRecordsAndOverrideIsTrue() throws Exception {
String domainName = "domain.name.com";
Domain domain = generateFakeDomain(domainName, false);
List<Record> recordList = new ArrayList<Record>();
for (int i = 0; i < 10; i++) {
Record record = new Record();
record.getTypeNSRecordAttributes().setDomainId(domain.getId());
record.getTypeNSRecordAttributes().setId(sequenceId++);
record.getTypeNSRecordAttributes().setType(new String[] {"A", "NS", "PTR"}[i % 3]);
recordList.add(record);
}
when(_recordApi.listAll(domain.getId())).thenReturn(recordList);
Answer answer = _globoDnsResource.execute(new RemoveDomainCommand(domainName, true));
assertEquals(true, answer.getResult());
verify(_domainApi, times(1)).removeDomain(eq(domain.getId()));
verify(_exportApi, times(1)).scheduleExport();
}
}