index int64 0 0 | repo_id stringlengths 26 205 | file_path stringlengths 51 246 | content stringlengths 8 433k | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/DesignateFunctions.java | package denominator.designate;
import java.util.List;
import java.util.Map;
import denominator.designate.Designate.Record;
import denominator.model.rdata.AAAAData;
import denominator.model.rdata.AData;
import denominator.model.rdata.CNAMEData;
import denominator.model.rdata.MXData;
import denominator.model.rdata.NSData;
import denominator.model.rdata.SRVData;
import denominator.model.rdata.TXTData;
import static denominator.common.Util.split;
public final class DesignateFunctions {
private DesignateFunctions() { /* */
}
static Map<String, Object> toRDataMap(Record record) {
if ("A".equals(record.type)) {
return AData.create(record.data);
} else if ("AAAA".equals(record.type)) {
return AAAAData.create(record.data);
} else if ("CNAME".equals(record.type)) {
return CNAMEData.create(record.data);
} else if ("MX".equals(record.type)) {
return MXData.create(record.priority, record.data);
} else if ("NS".equals(record.type)) {
return NSData.create(record.data);
} else if ("SRV".equals(record.type)) {
List<String> rdata = split(' ', record.data);
return SRVData.builder()
.priority(record.priority)
.weight(Integer.valueOf(rdata.get(0)))
.port(Integer.valueOf(rdata.get(1)))
.target(rdata.get(2)).build();
} else if ("TXT".equals(record.type)) {
return TXTData.create(record.data);
} else {
throw new UnsupportedOperationException("record type not yet supported" + record);
}
}
}
| 100 |
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/InvalidatableAuthProvider.java | package denominator.designate;
import java.net.URI;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Provider;
import javax.inject.Singleton;
import denominator.Credentials;
import denominator.designate.KeystoneV2.TokenIdAndPublicURL;
import static denominator.common.Preconditions.checkNotNull;
/**
* gets the current endpoint and authorization token from the identity service using password or api
* key auth.
*/
// similar to guava MemoizingSupplier
@Singleton
class InvalidatableAuthProvider implements Provider<TokenIdAndPublicURL> {
private final denominator.Provider provider;
private final KeystoneV2 identityService;
private final Provider<Credentials> credentials;
transient volatile String lastKeystoneUrl;
transient volatile int lastCredentialsHashCode;
transient volatile boolean initialized;
// "value" does not need to be volatile; visibility piggy-backs
// on above
transient TokenIdAndPublicURL value;
@Inject
InvalidatableAuthProvider(denominator.Provider provider, KeystoneV2 identityService,
javax.inject.Provider<Credentials> credentials) {
this.provider = provider;
this.identityService = identityService;
this.credentials = credentials;
// for toString
this.lastKeystoneUrl = provider.url();
}
public void invalidate() {
initialized = false;
}
@Override
public TokenIdAndPublicURL get() {
String currentUrl = provider.url();
Credentials currentCreds = credentials.get();
if (needsRefresh(currentUrl, currentCreds)) {
synchronized (this) {
if (needsRefresh(currentUrl, currentCreds)) {
lastCredentialsHashCode = currentCreds.hashCode();
lastKeystoneUrl = currentUrl;
TokenIdAndPublicURL t = auth(currentCreds);
value = t;
initialized = true;
return t;
}
}
}
return value;
}
private boolean needsRefresh(String currentUrl, Credentials currentCreds) {
return !initialized || currentCreds.hashCode() != lastCredentialsHashCode
|| !currentUrl.equals(lastKeystoneUrl);
}
private TokenIdAndPublicURL auth(Credentials currentCreds) {
String tenantId;
String username;
String password;
if (currentCreds instanceof List) {
@SuppressWarnings("unchecked")
List<Object> listCreds = (List<Object>) currentCreds;
tenantId = listCreds.get(0).toString();
username = listCreds.get(1).toString();
password = listCreds.get(2).toString();
} else if (currentCreds instanceof Map) {
@SuppressWarnings("unchecked")
Map<String, Object> mapCreds = (Map<String, Object>) currentCreds;
tenantId = checkNotNull(mapCreds.get("tenantId"), "tenantId").toString();
username = checkNotNull(mapCreds.get("username"), "username").toString();
password = checkNotNull(mapCreds.get("password"), "password").toString();
} else {
throw new IllegalArgumentException("Unsupported credential type: " + currentCreds);
}
URI url = URI.create(lastKeystoneUrl);
return identityService.passwordAuth(url, tenantId, username, password);
}
@Override
public String toString() {
return "InvalidatableAuthProvider(" + lastKeystoneUrl + ")";
}
}
| 101 |
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/KeystoneV2AccessAdapter.java | package denominator.designate;
import com.google.gson.JsonElement;
import com.google.gson.JsonIOException;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import denominator.designate.KeystoneV2.TokenIdAndPublicURL;
class KeystoneV2AccessAdapter extends TypeAdapter<TokenIdAndPublicURL> {
private final String serviceTypeSuffix = ":dns";
static boolean isNull(JsonElement element) {
return element == null || element.isJsonNull();
}
@Override
public TokenIdAndPublicURL read(JsonReader in) throws IOException {
JsonObject access;
try {
access = new JsonParser().parse(in).getAsJsonObject().get("access").getAsJsonObject();
} catch (JsonIOException e) {
if (e.getCause() != null && e.getCause() instanceof IOException) {
throw IOException.class.cast(e.getCause());
}
throw e;
}
JsonElement tokenField = access.get("token");
if (isNull(tokenField)) {
return null;
}
JsonElement idField = tokenField.getAsJsonObject().get("id");
if (isNull(idField)) {
return null;
}
TokenIdAndPublicURL tokenUrl = new TokenIdAndPublicURL();
tokenUrl.tokenId = idField.getAsString();
for (JsonElement s : access.get("serviceCatalog").getAsJsonArray()) {
JsonObject service = s.getAsJsonObject();
JsonElement typeField = service.get("type");
JsonElement endpointsField = service.get("endpoints");
if (!isNull(typeField) && !isNull(endpointsField) && typeField.getAsString()
.endsWith(serviceTypeSuffix)) {
for (JsonElement e : endpointsField.getAsJsonArray()) {
JsonObject endpoint = e.getAsJsonObject();
tokenUrl.publicURL = endpoint.get("publicURL").getAsString();
if (tokenUrl.publicURL.endsWith("/")) {
tokenUrl.publicURL = tokenUrl.publicURL.substring(0, tokenUrl.publicURL.length() - 1);
}
}
}
}
return tokenUrl;
}
@Override
public String toString() {
return "KeystoneV2AccessAdapter(" + serviceTypeSuffix + ")";
}
@Override
public void write(JsonWriter out, TokenIdAndPublicURL value) throws IOException {
throw new UnsupportedOperationException();
}
};
| 102 |
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/DesignateResourceRecordSetApi.java | package denominator.designate;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import denominator.ResourceRecordSetApi;
import denominator.designate.Designate.Record;
import denominator.model.ResourceRecordSet;
import static denominator.common.Preconditions.checkArgument;
import static denominator.common.Preconditions.checkNotNull;
import static denominator.common.Util.filter;
import static denominator.common.Util.join;
import static denominator.common.Util.nextOrNull;
import static denominator.designate.DesignateFunctions.toRDataMap;
import static denominator.model.ResourceRecordSets.nameAndTypeEqualTo;
import static denominator.model.ResourceRecordSets.nameEqualTo;
class DesignateResourceRecordSetApi implements denominator.ResourceRecordSetApi {
private final Designate api;
private final String domainId;
DesignateResourceRecordSetApi(Designate api, String domainId) {
this.api = api;
this.domainId = domainId;
}
@Override
public Iterator<ResourceRecordSet<?>> iterator() {
return new GroupByRecordNameAndTypeIterator(api.records(domainId).iterator());
}
@Override
public Iterator<ResourceRecordSet<?>> iterateByName(String name) {
// TODO: investigate query by name call in designate
return filter(iterator(), nameEqualTo(name));
}
@Override
public ResourceRecordSet<?> getByNameAndType(String name, String type) {
// TODO: investigate query by name and type call in designate
return nextOrNull(filter(iterator(), nameAndTypeEqualTo(name, type)));
}
@Override
public void put(ResourceRecordSet<?> rrset) {
checkNotNull(rrset, "rrset was null");
checkArgument(!rrset.records().isEmpty(), "rrset was empty %s", rrset);
List<Map<String, Object>>
recordsLeftToCreate =
new ArrayList<Map<String, Object>>(rrset.records());
for (Record record : api.records(domainId)) {
// TODO: name and type filter
if (rrset.name().equals(record.name) && rrset.type().equals(record.type)) {
Map<String, Object> rdata = toRDataMap(record);
if (recordsLeftToCreate.contains(rdata)) {
recordsLeftToCreate.remove(rdata);
if (rrset.ttl() != null) {
if (rrset.ttl().equals(record.ttl)) {
continue;
}
record.ttl = rrset.ttl();
api.updateRecord(domainId, record.id, record);
}
} else {
api.deleteRecord(domainId, record.id);
}
}
}
Record record = new Record();
record.name = rrset.name();
record.type = rrset.type();
record.ttl = rrset.ttl();
for (Map<String, Object> rdata : recordsLeftToCreate) {
LinkedHashMap<String, Object> mutable = new LinkedHashMap<String, Object>(rdata);
if (mutable.containsKey("priority")) { // SRVData
record.priority = Integer.class.cast(mutable.remove("priority"));
} else if (mutable.containsKey("preference")) { // MXData
record.priority = Integer.class.cast(mutable.remove("preference"));
} else {
record.priority = null;
}
record.data = join(' ', mutable.values().toArray());
api.createRecord(domainId, record);
}
}
@Override
public void deleteByNameAndType(String name, String type) {
checkNotNull(name, "name");
checkNotNull(type, "type");
for (Record record : api.records(domainId)) {
// TODO: name and type filter
if (name.equals(record.name) && type.equals(record.type)) {
api.deleteRecord(domainId, record.id);
}
}
}
static final class Factory implements denominator.ResourceRecordSetApi.Factory {
private final Designate api;
@Inject
Factory(Designate api) {
this.api = checkNotNull(api, "api");
}
@Override
public ResourceRecordSetApi create(String id) {
return new DesignateResourceRecordSetApi(api, checkNotNull(id, "id"));
}
}
}
| 103 |
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/DesignateTarget.java | package denominator.designate;
import javax.inject.Inject;
import denominator.Provider;
import denominator.designate.KeystoneV2.TokenIdAndPublicURL;
import feign.Request;
import feign.RequestTemplate;
import feign.Target;
class DesignateTarget implements Target<Designate> {
private final Provider provider;
private final InvalidatableAuthProvider lazyUrlAndToken;
@Inject
DesignateTarget(Provider provider, InvalidatableAuthProvider lazyUrlAndToken) {
this.provider = provider;
this.lazyUrlAndToken = lazyUrlAndToken;
}
@Override
public Class<Designate> type() {
return Designate.class;
}
@Override
public String name() {
return provider.name();
}
@Override
public String url() {
return lazyUrlAndToken.get().publicURL;
}
@Override
public Request apply(RequestTemplate input) {
TokenIdAndPublicURL urlAndToken = lazyUrlAndToken.get();
if (input.url().indexOf("http") != 0) {
input.insert(0, urlAndToken.publicURL);
}
input.header("X-Auth-Token", urlAndToken.tokenId);
return input.request();
}
}
| 104 |
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/DesignateZoneApi.java | package denominator.designate;
import java.util.Iterator;
import javax.inject.Inject;
import denominator.model.Zone;
import feign.FeignException;
import static denominator.common.Util.filter;
import static denominator.model.Zones.nameEqualTo;
class DesignateZoneApi implements denominator.ZoneApi {
private final Designate api;
@Inject
DesignateZoneApi(Designate api) {
this.api = api;
}
@Override
public Iterator<Zone> iterator() {
return api.domains().iterator();
}
/**
* Designate V1 does not have a filter by name api.
*/
@Override
public Iterator<Zone> iterateByName(String name) {
return filter(iterator(), nameEqualTo(name));
}
@Override
public String put(Zone zone) {
if (zone.id() != null) {
return api.updateDomain(zone.id(), zone.name(), zone.email(), zone.ttl()).id();
}
try {
return api.createDomain(zone.name(), zone.email(), zone.ttl()).id();
} catch (FeignException e) {
if (e.getMessage().indexOf(" 409 ") == -1) {
throw e;
}
String id = iterateByName(zone.name()).next().id();
return api.updateDomain(id, zone.name(), zone.email(), zone.ttl()).id();
}
}
@Override
public void delete(String id) {
try {
api.deleteDomain(id);
} catch (FeignException e) {
if (e.getMessage().indexOf(" 404 ") == -1) {
throw e;
}
}
}
}
| 105 |
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/LimitsReadable.java | package denominator.designate;
import javax.inject.Inject;
import denominator.CheckConnection;
class LimitsReadable implements CheckConnection {
private final Designate api;
@Inject
LimitsReadable(Designate api) {
this.api = api;
}
@Override
public boolean ok() {
try {
return api.limits() != null;
} catch (RuntimeException e) {
return false;
}
}
@Override
public String toString() {
return "LimitsReadable";
}
}
| 106 |
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/DesignateAdapters.java | package denominator.designate;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import denominator.designate.Designate.Record;
import denominator.model.Zone;
import static com.google.gson.stream.JsonToken.NULL;
class DesignateAdapters {
private static final Comparator<Object> TO_STRING_COMPARATOR = new Comparator<Object>() {
@Override
public int compare(Object left, Object right) {
return left.toString().compareTo(right.toString());
}
};
static Record buildRecord(JsonReader reader) throws IOException {
Record record = new Record();
while (reader.hasNext()) {
String key = reader.nextName();
if (key.equals("id")) {
record.id = reader.nextString();
} else if (key.equals("name")) {
record.name = reader.nextString();
} else if (key.equals("type")) {
record.type = reader.nextString();
} else if (key.equals("ttl") && reader.peek() != NULL) {
record.ttl = reader.nextInt();
} else if (key.equals("data")) {
record.data = reader.nextString();
} else if (key.equals("priority") && reader.peek() != NULL) {
record.priority = reader.nextInt();
} else {
reader.skipValue();
}
}
return record;
}
@SuppressWarnings("unchecked")
private static <X> Comparator<X> toStringComparator() {
return Comparator.class.cast(TO_STRING_COMPARATOR);
}
static class RecordAdapter extends TypeAdapter<Record> {
@Override
public void write(JsonWriter out, Record record) throws IOException {
out.beginObject();
out.name("name").value(record.name);
out.name("type").value(record.type);
if (record.ttl != null) {
out.name("ttl").value(record.ttl);
}
out.name("data").value(record.data);
if (record.priority != null) {
out.name("priority").value(record.priority);
}
out.endObject();
}
@Override
public Record read(JsonReader reader) throws IOException {
reader.beginObject();
Record record = buildRecord(reader);
reader.endObject();
return record;
}
}
static class DomainListAdapter extends ListAdapter<Zone> {
@Override
protected String jsonKey() {
return "domains";
}
protected Zone build(JsonReader reader) throws IOException {
String name = null, id = null, email = null;
int ttl = -1;
while (reader.hasNext()) {
String nextName = reader.nextName();
if (nextName.equals("id")) {
id = reader.nextString();
} else if (nextName.equals("name")) {
name = reader.nextString();
} else if (nextName.equals("ttl")) {
ttl = reader.nextInt();
} else if (nextName.equals("email")) {
email = reader.nextString();
} else {
reader.skipValue();
}
}
return Zone.create(id, name, ttl, email);
}
}
static class RecordListAdapter extends ListAdapter<Record> {
@Override
protected String jsonKey() {
return "records";
}
protected Record build(JsonReader reader) throws IOException {
return buildRecord(reader);
}
}
static abstract class ListAdapter<X> extends TypeAdapter<List<X>> {
protected abstract String jsonKey();
protected abstract X build(JsonReader reader) throws IOException;
@Override
public List<X> read(JsonReader reader) throws IOException {
List<X> elements = new LinkedList<X>();
reader.beginObject();
while (reader.hasNext()) {
String nextName = reader.nextName();
if (jsonKey().equals(nextName)) {
reader.beginArray();
while (reader.hasNext()) {
reader.beginObject();
elements.add(build(reader));
reader.endObject();
}
reader.endArray();
} else {
reader.skipValue();
}
}
reader.endObject();
Collections.sort(elements, toStringComparator());
return elements;
}
@Override
public void write(JsonWriter out, List<X> value) throws IOException {
throw new UnsupportedOperationException();
}
}
}
| 107 |
0 | Create_ds/denominator/designate/src/main/java/denominator | Create_ds/denominator/designate/src/main/java/denominator/designate/DesignateProvider.java | package denominator.designate;
import com.google.gson.TypeAdapter;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import javax.inject.Singleton;
import dagger.Provides;
import denominator.BasicProvider;
import denominator.CheckConnection;
import denominator.DNSApiManager;
import denominator.ResourceRecordSetApi;
import denominator.ZoneApi;
import denominator.config.GeoUnsupported;
import denominator.config.NothingToClose;
import denominator.config.OnlyBasicResourceRecordSets;
import denominator.config.WeightedUnsupported;
import denominator.designate.DesignateAdapters.DomainListAdapter;
import denominator.designate.DesignateAdapters.RecordAdapter;
import denominator.designate.DesignateAdapters.RecordListAdapter;
import feign.Feign;
import feign.Logger;
import feign.Target.EmptyTarget;
import feign.gson.GsonDecoder;
import feign.gson.GsonEncoder;
public class DesignateProvider extends BasicProvider {
private final String url;
public DesignateProvider() {
this(null);
}
/**
* @param url if empty or null use default
*/
public DesignateProvider(String url) {
this.url = url == null || url.isEmpty() ? "http://localhost:5000/v2.0" : url;
}
@Override
public String url() {
return url;
}
// http://docs.hpcloud.com/api/dns/#create_record-jumplink-span
@Override
public Set<String> basicRecordTypes() {
Set<String> types = new LinkedHashSet<String>();
types.addAll(Arrays.asList("A", "AAAA", "CNAME", "MX", "NS", "SRV", "TXT"));
return types;
}
@Override
public Map<String, Collection<String>> profileToRecordTypes() {
Map<String, Collection<String>>
profileToRecordTypes =
new LinkedHashMap<String, Collection<String>>();
profileToRecordTypes.put("roundRobin", Arrays.asList("A", "AAAA", "MX", "NS", "SRV", "TXT"));
return profileToRecordTypes;
}
@Override
public Map<String, Collection<String>> credentialTypeToParameterNames() {
Map<String, Collection<String>> options = new LinkedHashMap<String, Collection<String>>();
options.put("password", Arrays.asList("tenantId", "username", "password"));
return options;
}
@dagger.Module(injects = DNSApiManager.class, complete = false, overrides = true, includes = {
NothingToClose.class, GeoUnsupported.class, WeightedUnsupported.class,
OnlyBasicResourceRecordSets.class,
FeignModule.class})
public static final class Module {
@Provides
CheckConnection checkConnection(LimitsReadable checkConnection) {
return checkConnection;
}
@Provides
@Singleton
ZoneApi provideZoneApi(DesignateZoneApi in) {
return in;
}
@Provides
@Singleton
ResourceRecordSetApi.Factory provideResourceRecordSetApiFactory(
DesignateResourceRecordSetApi.Factory in) {
return in;
}
}
@dagger.Module(injects = DesignateResourceRecordSetApi.Factory.class,
complete = false // doesn't bind Provider used by DesignateTarget
)
public static final class FeignModule {
@Provides
@Singleton
Designate designate(Feign feign, DesignateTarget target) {
return feign.newInstance(target);
}
@Provides
@Singleton
KeystoneV2 keystoneV2(Feign feign) {
return feign.newInstance(EmptyTarget.create(KeystoneV2.class, "keystone"));
}
@Provides
Logger logger() {
return new Logger.NoOpLogger();
}
@Provides
Logger.Level logLevel() {
return Logger.Level.NONE;
}
@Provides
@Singleton
Feign feign(Logger logger, Logger.Level logLevel) {
RecordAdapter recordAdapter = new RecordAdapter();
return Feign.builder()
.logger(logger)
.logLevel(logLevel)
.encoder(new GsonEncoder(Collections.<TypeAdapter<?>>singleton(recordAdapter)))
.decoder(new GsonDecoder(Arrays.asList(
new KeystoneV2AccessAdapter(),
recordAdapter,
new DomainListAdapter(),
new RecordListAdapter()))
)
.build();
}
}
}
| 108 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSZoneWriteCommandsLiveTest.java | package denominator.ultradns;
import denominator.Live.UseTestGraph;
import denominator.ZoneWriteCommandsLiveTest;
@UseTestGraph(UltraDNSTestGraph.class)
public class UltraDNSZoneWriteCommandsLiveTest extends ZoneWriteCommandsLiveTest {
}
| 109 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSZoneApiMockTest.java | package denominator.ultradns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import denominator.ZoneApi;
import denominator.model.Zone;
import static denominator.assertj.ModelAssertions.assertThat;
import static denominator.ultradns.UltraDNSException.INVALID_ZONE_NAME;
import static denominator.ultradns.UltraDNSTest.getAccountsListOfUser;
import static denominator.ultradns.UltraDNSTest.getAccountsListOfUserResponse;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfDNameByType;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfDNameByTypeResponsePresent;
import static denominator.ultradns.UltraDNSTest.getZonesOfAccount;
import static denominator.ultradns.UltraDNSTest.getZonesOfAccountResponseAbsent;
import static denominator.ultradns.UltraDNSTest.getZonesOfAccountResponsePresent;
public class UltraDNSZoneApiMockTest {
@Rule
public final MockUltraDNSServer server = new MockUltraDNSServer();
@Test
public void iteratorWhenPresent() throws Exception {
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueue(new MockResponse().setBody(getZonesOfAccountResponsePresent));
server.enqueue(new MockResponse().setBody(getResourceRecordsOfDNameByTypeResponsePresent));
ZoneApi api = server.connect().api().zones();
assertThat(api.iterator()).containsExactly(
Zone.create("denominator.io.", "denominator.io.", 86400, "adrianc.netflix.com.")
);
server.assertSoapBody(getAccountsListOfUser);
server.assertSoapBody(getZonesOfAccount);
server.assertSoapBody(getResourceRecordsOfDNameByType);
}
@Test
public void iteratorWhenAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueue(new MockResponse().setBody(getZonesOfAccountResponseAbsent));
server.enqueue(new MockResponse().setBody(getResourceRecordsOfDNameByTypeResponsePresent));
ZoneApi api = server.connect().api().zones();
assertThat(api.iterator()).isEmpty();
server.assertSoapBody(getAccountsListOfUser);
server.assertSoapBody(getZonesOfAccount);
}
@Test
public void iteratorByName() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfDNameByTypeResponsePresent));
ZoneApi api = server.connect().api().zones();
assertThat(api.iterateByName("denominator.io.")).containsExactly(
Zone.create("denominator.io.", "denominator.io.", 86400, "adrianc.netflix.com.")
);
server.assertSoapBody(getResourceRecordsOfDNameByType);
}
@Test
public void iteratorByNameWhenNotFound() throws Exception {
server.enqueueError(INVALID_ZONE_NAME, "Invalid zone name.");
ZoneApi api = server.connect().api().zones();
assertThat(api.iterateByName("denominator.io.")).isEmpty();
server.assertSoapBody(getResourceRecordsOfDNameByType);
}
@Test
public void putWhenAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueue(new MockResponse());
server.enqueue(new MockResponse().setBody(getResourceRecordsOfDNameByTypeResponsePresent));
server.enqueue(new MockResponse());
ZoneApi api = server.connect().api().zones();
Zone zone = Zone.create(null, "denominator.io.", 3601, "nil@denominator.io");
assertThat(api.put(zone)).isEqualTo(zone.name());
server.assertSoapBody(getAccountsListOfUser);
server.assertSoapBody(
"<v01:createPrimaryZone><transactionID/><accountId>AAAAAAAAAAAAAAAA</accountId><zoneName>denominator.io.</zoneName><forceImport>false</forceImport></v01:createPrimaryZone>");
server.assertSoapBody(
"<v01:getResourceRecordsOfDNameByType><zoneName>denominator.io.</zoneName><hostName>denominator.io.</hostName><rrType>6</rrType></v01:getResourceRecordsOfDNameByType>");
server.assertSoapBody(
"<v01:updateResourceRecord><transactionID /><resourceRecord Guid=\"04053D8E57C7A22F\" ZoneName=\"denominator.io.\" Type=\"6\" DName=\"denominator.io.\" TTL=\"3601\"><InfoValues Info1Value=\"pdns75.ultradns.com.\" Info2Value=\"nil@denominator.io\" Info3Value=\"2013022200\" Info4Value=\"86400\" Info5Value=\"86400\" Info6Value=\"86400\" Info7Value=\"3601\" /></resourceRecord></v01:updateResourceRecord>");
}
@Test
public void putWhenPresent() throws Exception {
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueueError(1802, "Zone already exists in the system.");
server.enqueue(new MockResponse().setBody(getResourceRecordsOfDNameByTypeResponsePresent));
server.enqueue(new MockResponse());
ZoneApi api = server.connect().api().zones();
Zone zone = Zone.create(null, "denominator.io.", 3601, "nil@denominator.io");
assertThat(api.put(zone)).isEqualTo(zone.name());
server.assertSoapBody(getAccountsListOfUser);
server.assertSoapBody(
"<v01:createPrimaryZone><transactionID/><accountId>AAAAAAAAAAAAAAAA</accountId><zoneName>denominator.io.</zoneName><forceImport>false</forceImport></v01:createPrimaryZone>");
server.assertSoapBody(
"<v01:getResourceRecordsOfDNameByType><zoneName>denominator.io.</zoneName><hostName>denominator.io.</hostName><rrType>6</rrType></v01:getResourceRecordsOfDNameByType>");
server.assertSoapBody(
"<v01:updateResourceRecord><transactionID /><resourceRecord Guid=\"04053D8E57C7A22F\" ZoneName=\"denominator.io.\" Type=\"6\" DName=\"denominator.io.\" TTL=\"3601\"><InfoValues Info1Value=\"pdns75.ultradns.com.\" Info2Value=\"nil@denominator.io\" Info3Value=\"2013022200\" Info4Value=\"86400\" Info5Value=\"86400\" Info6Value=\"86400\" Info7Value=\"3601\" /></resourceRecord></v01:updateResourceRecord>");
}
@Test
public void deleteWhenPresent() throws Exception {
server.enqueue(new MockResponse());
ZoneApi api = server.connect().api().zones();
api.delete("denominator.io.");
server.assertSoapBody(
"<v01:deleteZone><transactionID /><zoneName>denominator.io.</zoneName></v01:deleteZone>");
}
@Test
public void deleteWhenAbsent() throws Exception {
server.enqueueError(1801, "Zone does not exist in the system.");
ZoneApi api = server.connect().api().zones();
api.delete("denominator.io.");
server.assertSoapBody(
"<v01:deleteZone><transactionID /><zoneName>denominator.io.</zoneName></v01:deleteZone>");
}
}
| 110 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSPredicatesTest.java | package denominator.ultradns;
import org.junit.Test;
import denominator.ultradns.UltraDNS.Record;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class UltraDNSPredicatesTest {
Record a;
public UltraDNSPredicatesTest() {
a = new Record();
a.id = "AAAAAAAAAAAA";
a.name = "foo.com.";
a.typeCode = 1;
a.ttl = 3600;
a.rdata.add("192.0.2.1");
}
@Test
public void resourceTypeEqualToFalseOnDifferentType() {
assertFalse(UltraDNSFilters.resourceTypeEqualTo(28).apply(a));
}
@Test
public void resourceTypeEqualToTrueOnSameType() {
assertTrue(UltraDNSFilters.resourceTypeEqualTo(a.typeCode).apply(a));
}
@Test
public void recordIdEqualToFalseOnDifferentId() {
assertFalse(UltraDNSFilters.recordIdEqualTo("BBBBBBBBBBBB").apply(a));
}
@Test
public void recordIdEqualToTrueOnSameId() {
assertTrue(UltraDNSFilters.recordIdEqualTo(a.id).apply(a));
}
}
| 111 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSErrorDecoderTest.java | package denominator.ultradns;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.util.Collection;
import java.util.Collections;
import feign.FeignException;
import feign.Response;
import feign.RetryableException;
import feign.codec.ErrorDecoder;
import static denominator.ultradns.MockUltraDNSServer.FAULT_TEMPLATE;
import static denominator.ultradns.UltraDNSException.SYSTEM_ERROR;
import static feign.Util.UTF_8;
import static java.lang.String.format;
/**
* Error decode tests not implicitly tested in {@linkplain denominator.ultradns.UltraDNSTest}.
*/
public class UltraDNSErrorDecoderTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
ErrorDecoder errors = new UltraDNSErrorDecoder(UltraDNSProvider.FeignModule.decoder());
static Response errorResponse(String body) {
return Response
.create(500, "Server Error", Collections.<String, Collection<String>>emptyMap(), body,
UTF_8);
}
@Test
public void noBody() throws Exception {
thrown.expect(FeignException.class);
thrown.expectMessage("status 500 reading UltraDNS#accountId()");
throw errors.decode("UltraDNS#accountId()", errorResponse(null));
}
@Test
public void systemError() throws Exception {
thrown.expect(RetryableException.class);
thrown.expectMessage("UltraDNS#networkStatus() failed with error 9999: System Error");
throw errors.decode("UltraDNS#networkStatus()",
errorResponse(format(FAULT_TEMPLATE, SYSTEM_ERROR, "System Error")));
}
}
| 112 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSGeoReadOnlyLiveTest.java | package denominator.ultradns;
import denominator.Live.UseTestGraph;
import denominator.profile.GeoReadOnlyLiveTest;
@UseTestGraph(UltraDNSTestGraph.class)
public class UltraDNSGeoReadOnlyLiveTest extends GeoReadOnlyLiveTest {
}
| 113 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSGeoWriteCommandsLiveTest.java | package denominator.ultradns;
import denominator.Live.UseTestGraph;
import denominator.profile.GeoWriteCommandsLiveTest;
@UseTestGraph(UltraDNSTestGraph.class)
public class UltraDNSGeoWriteCommandsLiveTest extends GeoWriteCommandsLiveTest {
}
| 114 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSProviderTest.java | package denominator.ultradns;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import dagger.ObjectGraph;
import denominator.Credentials.MapCredentials;
import denominator.DNSApiManager;
import denominator.Provider;
import static denominator.CredentialsConfiguration.credentials;
import static denominator.Denominator.create;
import static denominator.Providers.list;
import static denominator.Providers.provide;
import static org.assertj.core.api.Assertions.assertThat;
public class UltraDNSProviderTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
private static final Provider PROVIDER = new UltraDNSProvider();
@Test
public void testUltraDNSMetadata() {
assertThat(PROVIDER.name()).isEqualTo("ultradns");
assertThat(PROVIDER.supportsDuplicateZoneNames()).isFalse();
assertThat(PROVIDER.credentialTypeToParameterNames())
.containsEntry("password", Arrays.asList("username", "password"));
}
@Test
public void testUltraDNSRegistered() {
assertThat(list()).contains(PROVIDER);
}
@Test
public void testProviderWiresUltraDNSZoneApi() {
DNSApiManager manager = create(PROVIDER, credentials("username", "password"));
assertThat(manager.api().zones()).isInstanceOf(UltraDNSZoneApi.class);
manager = create("ultradns", credentials("username", "password"));
assertThat(manager.api().zones()).isInstanceOf(UltraDNSZoneApi.class);
Map<String, String> map = new LinkedHashMap<String, String>();
map.put("username", "U");
map.put("password", "P");
manager = create("ultradns", credentials(MapCredentials.from(map)));
assertThat(manager.api().zones()).isInstanceOf(UltraDNSZoneApi.class);
}
@Test
public void testCredentialsRequired() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("no credentials supplied. ultradns requires username,password");
create(PROVIDER).api().zones().iterator();
}
@Test
public void testTwoPartCredentialsRequired() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("incorrect credentials supplied. ultradns requires username,password");
create(PROVIDER, credentials("customer", "username", "password")).api().zones().iterator();
}
@Test
public void testViaDagger() {
DNSApiManager manager = ObjectGraph
.create(provide(new UltraDNSProvider()), new UltraDNSProvider.Module(),
credentials("username", "password"))
.get(DNSApiManager.class);
assertThat(manager.api().zones()).isInstanceOf(UltraDNSZoneApi.class);
}
}
| 115 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSTestGraph.java | package denominator.ultradns;
import denominator.DNSApiManagerFactory;
import static feign.Util.emptyToNull;
import static java.lang.System.getProperty;
public class UltraDNSTestGraph extends denominator.TestGraph {
private static final String url = emptyToNull(getProperty("ultradns.url"));
private static final String zone = emptyToNull(getProperty("ultradns.zone"));
public UltraDNSTestGraph() {
super(DNSApiManagerFactory.create(new UltraDNSProvider(url)), zone);
}
}
| 116 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSRoundRobinWriteCommandsLiveTest.java | package denominator.ultradns;
import denominator.Live.UseTestGraph;
import denominator.RoundRobinWriteCommandsLiveTest;
@UseTestGraph(UltraDNSTestGraph.class)
public class UltraDNSRoundRobinWriteCommandsLiveTest extends RoundRobinWriteCommandsLiveTest {
}
| 117 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/MockUltraDNSServer.java | package denominator.ultradns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import com.squareup.okhttp.mockwebserver.MockWebServer;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
import java.io.IOException;
import denominator.Credentials;
import denominator.CredentialsConfiguration;
import denominator.DNSApiManager;
import denominator.Denominator;
import denominator.assertj.RecordedRequestAssert;
import static denominator.Credentials.ListCredentials;
import static denominator.assertj.MockWebServerAssertions.assertThat;
import static denominator.ultradns.UltraDNSTarget.SOAP_TEMPLATE;
import static java.lang.String.format;
final class MockUltraDNSServer extends UltraDNSProvider implements TestRule {
/**
* param 1 is the code, 2 is the description
*/
static final String FAULT_TEMPLATE =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <soap:Fault>\n"
+ " <faultcode>soap:Server</faultcode>\n"
+ " <faultstring>Fault occurred while processing.</faultstring>\n"
+ " <detail>\n"
+ " <ns1:UltraWSException xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <errorCode xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"xs:int\">%s</errorCode>\n"
+ " <errorDescription xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">%s</errorDescription>\n"
+ " </ns1:UltraWSException>\n"
+ " </detail>\n"
+ " </soap:Fault>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
private final MockWebServer delegate = new MockWebServer();
private String username;
private String password;
private String soapTemplate;
MockUltraDNSServer() {
credentials("joe", "letmein");
}
@Override
public String url() {
return "http://localhost:" + delegate.getPort();
}
DNSApiManager connect() {
return Denominator.create(this, CredentialsConfiguration.credentials(credentials()));
}
Credentials credentials() {
return ListCredentials.from(username, password);
}
MockUltraDNSServer credentials(String username, String password) {
this.username = username;
this.password = password;
this.soapTemplate = format(SOAP_TEMPLATE, username, password, "%s");
return this;
}
void enqueueError(int code, String description) {
delegate.enqueue(
new MockResponse().setResponseCode(500).setBody(format(FAULT_TEMPLATE, code, description)));
}
void enqueue(MockResponse mockResponse) {
delegate.enqueue(mockResponse);
}
RecordedRequestAssert assertSoapBody(String soapBody) throws InterruptedException {
return assertThat(delegate.takeRequest())
.hasMethod("POST")
.hasPath("/")
.hasXMLBody(format(soapTemplate, soapBody));
}
void shutdown() throws IOException {
delegate.shutdown();
}
@Override
public Statement apply(Statement base, Description description) {
return delegate.apply(base, description);
}
@dagger.Module(injects = DNSApiManager.class, complete = false, includes =
UltraDNSProvider.Module.class)
static final class Module {
}
}
| 118 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSWriteCommandsLiveTest.java | package denominator.ultradns;
import denominator.Live.UseTestGraph;
import denominator.WriteCommandsLiveTest;
@UseTestGraph(UltraDNSTestGraph.class)
public class UltraDNSWriteCommandsLiveTest extends WriteCommandsLiveTest {
}
| 119 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/NetworkStatusReadableMockTest.java | package denominator.ultradns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import denominator.DNSApiManager;
import static denominator.ultradns.UltraDNSTest.getNeustarNetworkStatus;
import static denominator.ultradns.UltraDNSTest.getNeustarNetworkStatusResponse;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class NetworkStatusReadableMockTest {
@Rule
public final MockUltraDNSServer server = new MockUltraDNSServer();
@Test
public void singleRequestOnSuccess() throws Exception {
server.enqueue(new MockResponse().setBody(getNeustarNetworkStatusResponse));
DNSApiManager api = server.connect();
assertTrue(api.checkConnection());
server.assertSoapBody(getNeustarNetworkStatus);
}
@Test
public void singleRequestOnFailure() throws Exception {
server.enqueue(new MockResponse().setResponseCode(500));
DNSApiManager api = server.connect();
assertFalse(api.checkConnection());
server.assertSoapBody(getNeustarNetworkStatus);
}
}
| 120 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSProviderDynamicUpdateMockTest.java | package denominator.ultradns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import java.util.concurrent.atomic.AtomicReference;
import dagger.Module;
import dagger.Provides;
import denominator.Credentials;
import denominator.Credentials.ListCredentials;
import denominator.DNSApi;
import denominator.Denominator;
import static denominator.CredentialsConfiguration.credentials;
import static denominator.ultradns.UltraDNSTest.getAccountsListOfUser;
import static denominator.ultradns.UltraDNSTest.getAccountsListOfUserResponse;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfZoneResponseAbsent;
import static denominator.ultradns.UltraDNSTest.getZonesOfAccount;
import static denominator.ultradns.UltraDNSTest.getZonesOfAccountResponseAbsent;
public class UltraDNSProviderDynamicUpdateMockTest {
@Rule
public final MockUltraDNSServer server = new MockUltraDNSServer();
@Test
public void dynamicEndpointUpdates() throws Exception {
final AtomicReference<String> url = new AtomicReference<String>(server.url());
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueue(new MockResponse().setBody(getZonesOfAccountResponseAbsent));
DNSApi api = Denominator.create(new UltraDNSProvider() {
@Override
public String url() {
return url.get();
}
}, credentials(server.credentials())).api();
api.zones().iterator();
server.assertSoapBody(getAccountsListOfUser);
server.assertSoapBody(getZonesOfAccount);
MockUltraDNSServer server2 = new MockUltraDNSServer();
url.set(server2.url());
server2.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server2.enqueue(new MockResponse().setBody(getZonesOfAccountResponseAbsent));
api.zones().iterator();
server2.assertSoapBody(getAccountsListOfUser);
server2.assertSoapBody(getZonesOfAccount);
server2.shutdown();
}
@Test
public void dynamicCredentialUpdates() throws Exception {
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
AtomicReference<Credentials>
dynamicCredentials =
new AtomicReference<Credentials>(server.credentials());
DNSApi
api =
Denominator.create(server, new OverrideCredentials(dynamicCredentials)).api();
api.zones().iterator();
server.assertSoapBody(getAccountsListOfUser);
server.assertSoapBody(getZonesOfAccount);
dynamicCredentials.set(ListCredentials.from("bob", "comeon"));
server.credentials("bob", "comeon");
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
api.zones().iterator();
server.assertSoapBody(getAccountsListOfUser);
server.assertSoapBody(getZonesOfAccount);
}
@Test
public void dynamicAccountIdUpdatesOnEndpoint() throws Exception {
final AtomicReference<String> url = new AtomicReference<String>(server.url());
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueue(new MockResponse().setBody(getZonesOfAccountResponseAbsent));
DNSApi api = Denominator.create(new UltraDNSProvider() {
@Override
public String url() {
return url.get();
}
}, credentials(server.credentials())).api();
api.zones().iterator();
server.assertSoapBody(getAccountsListOfUser);
server.assertSoapBody(getZonesOfAccount);
MockUltraDNSServer server2 = new MockUltraDNSServer();
url.set(server2.url());
server2.enqueue(new MockResponse().setBody(
getAccountsListOfUserResponse.replace("AAAAAAAAAAAAAAAA", "BBBBBBBBBBBBBBBB")));
server2.enqueue(new MockResponse().setBody(getZonesOfAccountResponseAbsent));
api.zones().iterator();
server2.assertSoapBody(getAccountsListOfUser.replace("AAAAAAAAAAAAAAAA", "BBBBBBBBBBBBBBBB"));
server2.assertSoapBody(getZonesOfAccount.replace("AAAAAAAAAAAAAAAA", "BBBBBBBBBBBBBBBB"));
server2.shutdown();
}
@Test
public void dynamicAccountIdUpdatesOnCredentials() throws Exception {
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
AtomicReference<Credentials>
dynamicCredentials =
new AtomicReference<Credentials>(server.credentials());
DNSApi
api =
Denominator.create(server, new OverrideCredentials(dynamicCredentials)).api();
api.zones().iterator();
server.assertSoapBody(getAccountsListOfUser.replace("AAAAAAAAAAAAAAAA", "BBBBBBBBBBBBBBBB"));
server.assertSoapBody(getZonesOfAccount);
dynamicCredentials.set(ListCredentials.from("bob", "comeon"));
server.credentials("bob", "comeon");
server.enqueue(new MockResponse().setBody(
getAccountsListOfUserResponse.replace("AAAAAAAAAAAAAAAA", "BBBBBBBBBBBBBBBB")));
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
api.zones().iterator();
server.assertSoapBody(getAccountsListOfUser.replace("AAAAAAAAAAAAAAAA", "BBBBBBBBBBBBBBBB"));
server.assertSoapBody(getZonesOfAccount.replace("AAAAAAAAAAAAAAAA", "BBBBBBBBBBBBBBBB"));
}
@Module(complete = false, library = true, overrides = true)
static class OverrideCredentials {
final AtomicReference<Credentials> dynamicCredentials;
OverrideCredentials(AtomicReference<Credentials> dynamicCredentials) {
this.dynamicCredentials = dynamicCredentials;
}
@Provides
public Credentials get() {
return dynamicCredentials.get();
}
}
}
| 121 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSTest.java | package denominator.ultradns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import denominator.Credentials;
import denominator.ultradns.UltraDNS.DirectionalGroup;
import denominator.ultradns.UltraDNS.DirectionalRecord;
import denominator.ultradns.UltraDNS.NameAndType;
import denominator.ultradns.UltraDNS.NetworkStatus;
import denominator.ultradns.UltraDNS.Record;
import feign.Feign;
import feign.codec.DecodeException;
import static denominator.assertj.ModelAssertions.assertThat;
import static denominator.ultradns.UltraDNSException.DIRECTIONALPOOL_NOT_FOUND;
import static denominator.ultradns.UltraDNSException.DIRECTIONALPOOL_RECORD_NOT_FOUND;
import static denominator.ultradns.UltraDNSException.GROUP_NOT_FOUND;
import static denominator.ultradns.UltraDNSException.INVALID_ZONE_NAME;
import static denominator.ultradns.UltraDNSException.POOL_ALREADY_EXISTS;
import static denominator.ultradns.UltraDNSException.POOL_NOT_FOUND;
import static denominator.ultradns.UltraDNSException.POOL_RECORD_ALREADY_EXISTS;
import static denominator.ultradns.UltraDNSException.RESOURCE_RECORD_ALREADY_EXISTS;
import static denominator.ultradns.UltraDNSException.RESOURCE_RECORD_NOT_FOUND;
import static denominator.ultradns.UltraDNSException.SYSTEM_ERROR;
import static java.lang.String.format;
import static java.util.Arrays.asList;
import static org.assertj.core.groups.Tuple.tuple;
public class UltraDNSTest {
@Rule
public final MockUltraDNSServer server = new MockUltraDNSServer();
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void networkGood() throws Exception {
server.enqueue(new MockResponse().setBody(getNeustarNetworkStatusResponse));
assertThat(mockApi().getNeustarNetworkStatus()).isEqualTo(NetworkStatus.GOOD);
server.assertSoapBody(getNeustarNetworkStatus);
}
@Test
public void networkFailed() throws Exception {
server.enqueue(new MockResponse().setBody(getNeustarNetworkStatusFailedResponse));
assertThat(mockApi().getNeustarNetworkStatus()).isEqualTo(NetworkStatus.FAILED);
server.assertSoapBody(getNeustarNetworkStatus);
}
@Test
public void retryOnSystemError() throws Exception {
server.enqueueError(SYSTEM_ERROR, "System Error");
server.enqueue(new MockResponse().setBody(getNeustarNetworkStatusResponse));
assertThat(mockApi().getNeustarNetworkStatus()).isEqualTo(NetworkStatus.GOOD);
server.assertSoapBody(getNeustarNetworkStatus);
server.assertSoapBody(getNeustarNetworkStatus);
}
@Test
public void noRetryOnInvalidUser() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("UltraDNS#getNeustarNetworkStatus() failed: Invalid User");
server.enqueue(new MockResponse().setResponseCode(500).setBody(invalidUser));
mockApi().getNeustarNetworkStatus();
}
@Test
public void networkStatusCantParse() throws Exception {
thrown.expect(DecodeException.class);
thrown.expectMessage("Content is not allowed in prolog.");
server.enqueue(new MockResponse().setBody("{\"foo\": \"bar\"}"));
mockApi().getNeustarNetworkStatus();
}
@Test
public void accountId() throws Exception {
server.enqueue(new MockResponse().setBody(getAccountsListOfUserResponse));
assertThat(mockApi().getAccountsListOfUser()).isEqualTo("AAAAAAAAAAAAAAAA");
server.assertSoapBody(getAccountsListOfUser);
}
@Test
public void zonesOfAccountPresent() throws Exception {
server.enqueue(new MockResponse().setBody(getZonesOfAccountResponsePresent));
assertThat(mockApi().getZonesOfAccount("AAAAAAAAAAAAAAAA"))
.containsExactly("denominator.io.");
server.assertSoapBody(getZonesOfAccount);
}
@Test
public void zonesOfAccountAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getZonesOfAccountResponseAbsent));
assertThat(mockApi().getZonesOfAccount("AAAAAAAAAAAAAAAA")).isEmpty();
server.assertSoapBody(getZonesOfAccount);
}
@Test
public void recordsInZonePresent() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponsePresent));
List<Record> records = mockApi().getResourceRecordsOfZone("denominator.io.");
assertThat(records).extracting("id", "created")
.containsExactly(
tuple("0B0338C2023F7969", 1255348943000L),
tuple("04023A2507B6468F", 1286038636000L)
);
assertThat(records).extracting("name", "typeCode", "ttl", "rdata")
.containsExactly(
tuple("denominator.io.", 2, 86400, asList("pdns2.ultradns.net.")),
tuple("www.denominator.io.", 1, 3600, asList("1.2.3.4"))
);
server.assertSoapBody(getResourceRecordsOfZone);
}
@Test
public void recordsInZoneAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
assertThat(mockApi().getResourceRecordsOfZone("denominator.io.")).isEmpty();
server.assertSoapBody(getResourceRecordsOfZone);
}
@Test
public void recordsInZoneByNameAndTypePresent() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfDNameByTypeResponsePresent));
assertThat(mockApi().getResourceRecordsOfDNameByType("denominator.io.", "denominator.io.", 6))
.extracting("id", "created", "name", "typeCode", "ttl", "rdata")
.contains(
tuple("04053D8E57C7A22F", 1361521368000L, "denominator.io.", 6, 86400, asList(
"pdns75.ultradns.com.",
"adrianc.netflix.com.",
"2013022200",
"86400",
"86400",
"86400",
"86400"))
);
server.assertSoapBody(getResourceRecordsOfDNameByType);
}
@Test
public void recordsInZoneByNameAndTypeAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfDNameByTypeResponseAbsent));
assertThat(mockApi().getResourceRecordsOfDNameByType("denominator.io.", "denominator.io.", 6))
.isEmpty();
server.assertSoapBody(getResourceRecordsOfDNameByType);
}
@Test
public void recordsInZoneByNameAndTypeInvalidZone() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("2507: Invalid zone name.");
server.enqueueError(INVALID_ZONE_NAME, "Invalid zone name.");
mockApi().getResourceRecordsOfDNameByType("ARGHH", "ARGHH", 6);
}
@Test
public void createRecordInZone() throws Exception {
server.enqueue(new MockResponse().setBody(createResourceRecordResponse));
Record record = new Record();
record.name = "mail.denominator.io.";
record.typeCode = 15;
record.ttl = 1800;
record.rdata.add("10");
record.rdata.add("maileast.denominator.io.");
mockApi().createResourceRecord(record, "denominator.io.");
server.assertSoapBody(createResourceRecord);
}
@Test
public void updateRecordInZone() throws Exception {
server.enqueue(new MockResponse().setBody(updateResourceRecordResponse));
Record record = new Record();
record.id = "ABCDEF";
record.name = "www.denominator.io.";
record.typeCode = 1;
record.ttl = 3600;
record.rdata.add("1.1.1.1");
mockApi().updateResourceRecord(record, "denominator.io.");
server.assertSoapBody(
"<v01:updateResourceRecord><transactionID /><resourceRecord Guid=\"ABCDEF\" ZoneName=\"denominator.io.\" Type=\"1\" DName=\"www.denominator.io.\" TTL=\"3600\"><InfoValues Info1Value=\"1.1.1.1\" /></resourceRecord></v01:updateResourceRecord>");
}
@Test
public void updateRecordOfRRPool() throws Exception {
server.enqueue(new MockResponse().setBody(updateResourceRecordResponse));
mockApi().updateRecordOfRRPool("ABCDEF", "000000000000002", "1.1.1.1", 3600);
server.assertSoapBody("<v01:updateRecordOfRRPool>\n"
+ " <transactionID/>\n"
+ " <resourceRecord TTL=\"3600\" info1Value=\"1.1.1.1\" lbPoolID=\"000000000000002\" rrGuid=\"ABCDEF\"/>\n"
+ "</v01:updateRecordOfRRPool>");
}
/**
* Granted, this doesn't make sense, but testing found update to return this error.
*/
@Test
public void updateRecordInZoneAlreadyExists() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage(
"2111: Resource Record of type 1 with these attributes already exists in the system.");
server.enqueueError(RESOURCE_RECORD_ALREADY_EXISTS,
"Resource Record of type 1 with these attributes already exists in the system.");
Record record = new Record();
record.id = "ABCDEF";
record.name = "www.denominator.io.";
record.typeCode = 1;
record.ttl = 3600;
record.rdata.add("1.1.1.1");
mockApi().updateResourceRecord(record, "denominator.io.");
}
@Test
public void deleteRecord() throws Exception {
server.enqueue(new MockResponse().setBody(deleteResourceRecordResponse));
mockApi().deleteResourceRecord("ABCDEF");
server.assertSoapBody(deleteResourceRecord);
}
@Test
public void rrPoolNameTypeToIdInZonePresent() throws Exception {
server.enqueue(new MockResponse().setBody(getLoadBalancingPoolsByZoneResponsePresent));
NameAndType one = new NameAndType();
one.name = "app-uswest1.denominator.io.";
one.type = "A";
NameAndType two = new NameAndType();
two.name = "app-uswest2.denominator.io.";
two.type = "A";
assertThat(mockApi().getLoadBalancingPoolsByZone("denominator.io."))
.containsEntry(one, "000000000000002")
.containsEntry(two, "000000000000003");
server.assertSoapBody(getLoadBalancingPoolsByZone);
}
@Test
public void rrPoolNameTypeToIdInZoneAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getLoadBalancingPoolsByZoneResponseAbsent));
assertThat(mockApi().getLoadBalancingPoolsByZone("denominator.io.")).isEmpty();
server.assertSoapBody(getLoadBalancingPoolsByZone);
}
@Test
public void recordsInRRPoolPresent() throws Exception {
server.enqueue(new MockResponse().setBody(getRRPoolRecordsResponsePresent));
assertThat(mockApi().getRRPoolRecords("000000000000002"))
.extracting("id", "created", "name", "typeCode", "ttl", "rdata")
.containsExactly(
tuple("0B0338C2023F7969", 1255348943000L, "denominator.io.", 2, 86400, asList(
"pdns2.ultradns.net.")),
tuple("04023A2507B6468F", 1286038636000L, "www.denominator.io.", 1, 3600, asList(
"1.2.3.4"))
);
server.assertSoapBody(getRRPoolRecords);
}
@Test
public void recordsInRRPoolAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getRRPoolRecordsResponseAbsent));
assertThat(mockApi().getRRPoolRecords("000000000000002")).isEmpty();
server.assertSoapBody(getRRPoolRecords);
}
@Test
public void createRRPoolInZoneForNameAndType() throws Exception {
server.enqueue(new MockResponse().setBody(addRRLBPoolResponse));
assertThat(mockApi().addRRLBPool("denominator.io.", "www.denominator.io.", 1))
.isEqualTo("AAAAAAAAAAAAAAAA");
server.assertSoapBody(addRRLBPool);
}
@Test
public void createRRPoolInZoneForNameAndTypeWhenAlreadyExists() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("2912: Pool already created for this host name : www.denominator.io.");
server.enqueueError(POOL_ALREADY_EXISTS,
"Pool already created for this host name : www.denominator.io.");
mockApi().addRRLBPool("denominator.io.", "www.denominator.io.", 1);
}
@Test
public void addRecordIntoRRPoolInZone() throws Exception {
server.enqueue(new MockResponse().setBody(addRecordToRRPoolResponse));
mockApi().addRecordToRRPool(1, 300, "www1.denominator.io.", "AAAAAAAAAAAAAAAA",
"denominator.io.");
server.assertSoapBody(addRecordToRRPool);
}
@Test
public void deleteRRPool() throws Exception {
server.enqueue(new MockResponse().setBody(deleteLBPoolResponse));
mockApi().deleteLBPool("AAAAAAAAAAAAAAAA");
server.assertSoapBody(deleteLBPool);
}
@Test
public void deleteRRPoolWhenPoolNotFound() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("2911: Pool does not exist in the system");
server.enqueueError(POOL_NOT_FOUND, "Pool does not exist in the system");
mockApi().deleteLBPool("AAAAAAAAAAAAAAAA");
}
@Test
public void deleteRRPoolWhenRecordNotFound() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("2103: No resource record with GUID found in the system AAAAAAAAAAAAAAAA");
server.enqueueError(RESOURCE_RECORD_NOT_FOUND,
"No resource record with GUID found in the system AAAAAAAAAAAAAAAA");
mockApi().deleteLBPool("AAAAAAAAAAAAAAAA");
}
@Test
public void dirPoolNameToIdsInZonePresent() throws Exception {
server.enqueue(new MockResponse().setBody(getDirectionalPoolsOfZoneResponsePresent));
assertThat(mockApi().getDirectionalPoolsOfZone("denominator.io."))
.containsEntry("www.denominator.io.", "D000000000000001");
server.assertSoapBody(getDirectionalPoolsOfZone);
}
@Test
public void dirPoolNameToIdsInZoneAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getDirectionalPoolsOfZoneResponseAbsent));
assertThat(mockApi().getDirectionalPoolsOfZone("denominator.io.")).isEmpty();
server.assertSoapBody(getDirectionalPoolsOfZone);
}
@Test
public void directionalRecordsByNameAndTypePresent() throws Exception {
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForHostResponsePresent));
List<DirectionalRecord> records = mockApi().getDirectionalDNSRecordsForHost(
"denominator.io.", "www.denominator.io.", 0);
assertThat(records).extracting("geoGroupId", "geoGroupName", "noResponseRecord", "id")
.containsExactly(
tuple("C000000000000001", "Europe", false, "A000000000000001"),
tuple("C000000000000003", "Everywhere Else", false, "A000000000000003"),
tuple("C000000000000002", "US", false, "A000000000000002")
);
assertThat(records).extracting("type", "ttl", "rdata")
.containsExactly(
tuple("CNAME", 300, asList("www-000000001.eu-west-1.elb.amazonaws.com.")),
tuple("CNAME", 60, asList("www-000000002.us-east-1.elb.amazonaws.com.")),
tuple("CNAME", 300, asList("www-000000001.us-east-1.elb.amazonaws.com."))
);
server.assertSoapBody(getDirectionalDNSRecordsForHost);
}
@Test
public void directionalRecordsByNameAndTypeAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForHostResponseAbsent));
assertThat(
mockApi().getDirectionalDNSRecordsForHost("denominator.io.", "www.denominator.io.", 0))
.isEmpty();
server.assertSoapBody(getDirectionalDNSRecordsForHost);
}
@Test
public void directionalRecordsByNameAndTypeWhenPoolNotFound() {
thrown.expect(UltraDNSException.class);
thrown.expectMessage(
"2142: No Pool or Multiple pools of same type exists for the PoolName : www.denominator.io.");
server.enqueueError(DIRECTIONALPOOL_NOT_FOUND,
"No Pool or Multiple pools of same type exists for the PoolName : www.denominator.io.");
mockApi().getDirectionalDNSRecordsForHost("denominator.io.", "www.denominator.io.", 0);
}
@Test
public void directionalRecordsByNameAndTypeFiltersOutSourceIP() throws Exception {
server.enqueue(
new MockResponse().setBody(getDirectionalDNSRecordsForHostResponseFiltersOutSourceIP));
List<DirectionalRecord> records = mockApi().getDirectionalDNSRecordsForHost(
"denominator.io.", "www.denominator.io.", 0);
assertThat(records).extracting("geoGroupId", "geoGroupName", "noResponseRecord", "id")
.containsExactly(tuple("C000000000000002", "US", false, "A000000000000002"));
assertThat(records).extracting("type", "ttl", "rdata")
.containsExactly(tuple("CNAME", 300, asList("www-000000001.us-east-1.elb.amazonaws.com.")));
server.assertSoapBody(getDirectionalDNSRecordsForHost);
}
@Test
public void directionalRecordsInZoneAndGroupByNameAndTypePresent() throws Exception {
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForGroupResponsePresent));
List<DirectionalRecord> records = mockApi().getDirectionalDNSRecordsForGroup(
"denominator.io.", "Europe", "www.denominator.io.", 1);
assertThat(records).extracting("geoGroupId", "geoGroupName", "noResponseRecord", "id")
.containsExactly(tuple("C000000000000001", "Europe", false, "A000000000000001"));
assertThat(records).extracting("type", "ttl", "rdata")
.containsExactly(tuple("CNAME", 300, asList("www-000000001.eu-west-1.elb.amazonaws.com.")));
server.assertSoapBody(getDirectionalDNSRecordsForGroup);
}
@Test
public void directionalRecordsInZoneAndGroupByNameAndTypeAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForGroupResponseAbsent));
assertThat(mockApi().getDirectionalDNSRecordsForGroup("denominator.io.", "Europe",
"www.denominator.io.", 1))
.isEmpty();
server.assertSoapBody(getDirectionalDNSRecordsForGroup);
}
@Test
public void directionalRecordsInZoneAndGroupByNameAndTypeWhenGroupNotFound() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("4003: Group does not exist.");
server.enqueueError(GROUP_NOT_FOUND, "Group does not exist.");
mockApi().getDirectionalDNSRecordsForGroup("denominator.io.", "Europe",
"www.denominator.io.", 1);
}
@Test
public void createDirectionalPoolInZoneForNameAndType() throws Exception {
server.enqueue(new MockResponse().setBody(addDirectionalPoolResponse));
assertThat(mockApi().addDirectionalPool("denominator.io.", "www.denominator.io.", "A"))
.isEqualTo("AAAAAAAAAAAAAAAA");
server.assertSoapBody(addDirectionalPool);
}
@Test
public void createDirectionalPoolInZoneForNameAndTypeWhenAlreadyExists() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("2912: Pool already created for this host name : www.denominator.io.");
server.enqueueError(POOL_ALREADY_EXISTS,
"Pool already created for this host name : www.denominator.io.");
mockApi().addDirectionalPool("denominator.io.", "www.denominator.io.", "A");
}
@Test
public void deleteDirectionalPool() throws Exception {
server.enqueue(new MockResponse().setBody(deleteDirectionalPoolResponse));
mockApi().deleteDirectionalPool("AAAAAAAAAAAAAAAA");
server.assertSoapBody(deleteDirectionalPool);
}
@Test
public void deleteDirectionalRecord() throws Exception {
server.enqueue(new MockResponse().setBody(deleteDirectionalPoolRecordResponse));
mockApi().deleteDirectionalPoolRecord("00000000000");
server.assertSoapBody(deleteDirectionalPoolRecord);
}
@Test
public void deleteDirectionalRecordNotFound() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("2705: Directional Pool Record does not exist in the system");
server.enqueueError(DIRECTIONALPOOL_RECORD_NOT_FOUND,
"Directional Pool Record does not exist in the system");
mockApi().deleteDirectionalPoolRecord("00000000000");
}
@Test
public void createDirectionalRecordAndGroupInPool() throws Exception {
server.enqueue(new MockResponse().setBody(addDirectionalPoolRecordResponse));
DirectionalRecord record = new DirectionalRecord();
record.name = "mail.denominator.io.";
record.type = "MX";
record.ttl = 1800;
record.rdata.add("10");
record.rdata.add("maileast.denominator.io.");
DirectionalGroup group = new DirectionalGroup();
group.name = "Mexas";
group.regionToTerritories.put("United States (US)", asList("Maryland", "Texas"));
assertThat(mockApi().addDirectionalPoolRecord(record, group, "AAAAAAAAAAAAAAAA"))
.isEqualTo("06063DC355058294");
server.assertSoapBody(addDirectionalPoolRecord);
}
@Test
public void createDirectionalRecordAndGroupInPoolWhenExists() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage("4009: Resource Record already exists.");
server.enqueueError(POOL_RECORD_ALREADY_EXISTS, "Resource Record already exists.");
DirectionalRecord record = new DirectionalRecord();
record.name = "mail.denominator.io.";
record.type = "MX";
record.ttl = 1800;
record.rdata.add("10");
record.rdata.add("maileast.denominator.io.");
DirectionalGroup group = new DirectionalGroup();
group.name = "Mexas";
group.regionToTerritories.put("United States (US)", asList("Maryland", "Texas"));
mockApi().addDirectionalPoolRecord(record, group, "AAAAAAAAAAAAAAAA");
}
@Test
public void updateDirectionalRecordAndGroup() throws Exception {
server.enqueue(new MockResponse().setBody(updateDirectionalPoolRecordResponse));
DirectionalRecord record = new DirectionalRecord();
record.id = "A000000000000001";
record.name = "www.denominator.io.";
record.type = "CNAME";
record.ttl = 300;
record.rdata.add("www-000000001.eu-west-1.elb.amazonaws.com.");
DirectionalGroup group = new DirectionalGroup();
group.name = "Europe";
group.regionToTerritories.put("Europe", asList("Aland Islands"));
mockApi().updateDirectionalPoolRecord(record, group);
server.assertSoapBody(updateDirectionalPoolRecordRegions);
}
@Test
public void updateDirectionalRecordAndGroupWhenExistsWithSameAttributes() throws Exception {
thrown.expect(UltraDNSException.class);
thrown.expectMessage(
"2111: Resource Record of type CNAME with these attributes already exists in the system.");
server.enqueueError(RESOURCE_RECORD_ALREADY_EXISTS,
"Resource Record of type CNAME with these attributes already exists in the system.");
DirectionalRecord record = new DirectionalRecord();
record.id = "ABCDEF";
record.name = "mail.denominator.io.";
record.type = "MX";
record.ttl = 1800;
record.rdata.add("10");
record.rdata.add("maileast.denominator.io.");
DirectionalGroup group = new DirectionalGroup();
group.name = "Mexas";
group.regionToTerritories.put("United States (US)", asList("Maryland", "Texas"));
mockApi().updateDirectionalPoolRecord(record, group);
}
@Test
public void getDirectionalGroup() throws Exception {
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEurope));
DirectionalGroup
group =
mockApi().getDirectionalDNSGroupDetails("AAAAAAAAAAAAAAAA");
assertThat(group.name).isEqualTo("Europe");
assertThat(group.regionToTerritories)
.containsEntry("Europe", asList("Aland Islands", "Albania", "Andorra", "Armenia", "Austria",
"Azerbaijan", "Belarus", "Belgium", "Bosnia-Herzegovina",
"Bulgaria", "Croatia", "Czech Republic", "Denmark",
"Estonia",
"Faroe Islands", "Finland", "France", "Georgia", "Germany",
"Gibraltar", "Greece", "Guernsey", "Hungary", "Iceland",
"Ireland", "Isle of Man", "Italy", "Jersey", "Latvia",
"Liechtenstein", "Lithuania", "Luxembourg",
"Macedonia, the former Yugoslav Republic of", "Malta",
"Moldova, Republic of", "Monaco", "Montenegro",
"Netherlands",
"Norway", "Poland", "Portugal", "Romania", "San Marino",
"Serbia", "Slovakia", "Slovenia", "Spain",
"Svalbard and Jan Mayen", "Sweden", "Switzerland",
"Ukraine",
"Undefined Europe",
"United Kingdom - England, Northern Ireland, Scotland, Wales",
"Vatican City"));
server.assertSoapBody(getDirectionalDNSGroupDetails);
}
@Test
public void getRegionsByIdAndName() throws Exception {
server.enqueue(new MockResponse().setBody(getAvailableRegionsResponse));
Map<String, Collection<String>> group = mockApi().getAvailableRegions();
assertThat(group)
.containsEntry("Anonymous Proxy (A1)", asList("Anonymous Proxy"))
.containsEntry("Antarctica",
asList("Antarctica", "Bouvet Island", "French Southern Territories"));
server.assertSoapBody(getAvailableRegions);
}
UltraDNS mockApi() {
UltraDNSProvider.FeignModule module = new UltraDNSProvider.FeignModule();
Feign feign = module.feign(module.logger(), module.logLevel());
return feign.newInstance(new UltraDNSTarget(new UltraDNSProvider() {
@Override
public String url() {
return server.url();
}
}, new javax.inject.Provider<Credentials>() {
@Override
public Credentials get() {
return server.credentials();
}
}));
}
static String getNeustarNetworkStatus = "<v01:getNeustarNetworkStatus/>";
static String getNeustarNetworkStatusResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getNeustarNetworkStatusResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <NeustarNetworkStatus xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">Good</NeustarNetworkStatus>\n"
+ " </ns1:getNeustarNetworkStatusResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getNeustarNetworkStatusFailedResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getNeustarNetworkStatusResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <NeustarNetworkStatus xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">Failed</NeustarNetworkStatus>\n"
+ " </ns1:getNeustarNetworkStatusResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String invalidUser =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <soap:Fault>\n"
+ " <faultcode>soap:Client</faultcode>\n"
+ " <faultstring>Invalid User</faultstring>\n"
+ " </soap:Fault>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getAccountsListOfUser = "<v01:getAccountsListOfUser/>";
static String getAccountsListOfUserResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getAccountsListOfUserResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <AccountsList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">\n"
+ " <ns2:AccountDetailsData accountID=\"AAAAAAAAAAAAAAAA\" accountName=\"denominator\" />\n"
+ " </AccountsList>\n"
+ " </ns1:getAccountsListOfUserResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
getZonesOfAccount =
"<v01:getZonesOfAccount><accountId>AAAAAAAAAAAAAAAA</accountId><zoneType>all</zoneType></v01:getZonesOfAccount>";
static String getZonesOfAccountResponseHeader =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getZonesOfAccountResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <ZoneList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">\n";
static String getZonesOfAccountResponseFooter = " </ZoneList>\n"
+ " </ns1:getZonesOfAccountResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getZonesOfAccountResponsePresent = getZonesOfAccountResponseHeader
+ " <ns2:UltraZone zoneName=\"denominator.io.\" zoneType=\"1\" accountId=\"AAAAAAAAAAAAAAAA\" owner=\"EEEEEEEEEEEEEEE\" zoneId=\"0000000000000001\" dnssecStatus=\"UNSIGNED\"/>\n"
+ getZonesOfAccountResponseFooter;
static String getZonesOfAccountResponseAbsent =
getZonesOfAccountResponseHeader + getZonesOfAccountResponseFooter;
static String
getResourceRecordsOfZone =
"<v01:getResourceRecordsOfZone><zoneName>denominator.io.</zoneName><rrType>0</rrType></v01:getResourceRecordsOfZone>";
static String getResourceRecordsOfZoneResponseHeader =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getResourceRecordsOfZoneResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <ResourceRecordList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">\n";
static String getResourceRecordsOfZoneResponseFooter = " </ResourceRecordList>\n"
+ " </ns1:getResourceRecordsOfZoneResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getResourceRecordsOfZoneResponseAbsent = getResourceRecordsOfZoneResponseHeader
+ getResourceRecordsOfZoneResponseFooter;
static String
getResourceRecordsOfDNameByType =
"<v01:getResourceRecordsOfDNameByType><zoneName>denominator.io.</zoneName><hostName>denominator.io.</hostName><rrType>6</rrType></v01:getResourceRecordsOfDNameByType>";
static String getResourceRecordsOfDNameByTypeResponseHeader =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getResourceRecordsOfDNameByTypeResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <ResourceRecordList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">\n";
static String getResourceRecordsOfDNameByTypeResponseFooter = " </ResourceRecordList>\n"
+ " </ns1:getResourceRecordsOfDNameByTypeResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getResourceRecordsOfDNameByTypeResponsePresent =
getResourceRecordsOfDNameByTypeResponseHeader
+ " <ns2:ResourceRecord ZoneName=\"denominator.io.\" Type=\"6\" DName=\"denominator.io.\" TTL=\"86400\" Guid=\"04053D8E57C7A22F\" ZoneId=\"03053D8E57C7A22A\" LName=\"denominator.io.\" Created=\"2013-02-22T08:22:48.000Z\" Modified=\"2013-02-22T08:22:49.000Z\">\n"
+ " <ns2:InfoValues Info1Value=\"pdns75.ultradns.com.\" Info2Value=\"adrianc.netflix.com.\" Info3Value=\"2013022200\" Info4Value=\"86400\" Info5Value=\"86400\" Info6Value=\"86400\" Info7Value=\"86400\" />\n"
+ " </ns2:ResourceRecord>\n"
+ getResourceRecordsOfDNameByTypeResponseFooter;
static String getResourceRecordsOfDNameByTypeResponseAbsent =
getResourceRecordsOfDNameByTypeResponseHeader
+ getResourceRecordsOfDNameByTypeResponseFooter;
static String
createResourceRecord =
"<v01:createResourceRecord><transactionID /><resourceRecord ZoneName=\"denominator.io.\" Type=\"15\" DName=\"mail.denominator.io.\" TTL=\"1800\"><InfoValues Info1Value=\"10\" Info2Value=\"maileast.denominator.io.\" /></resourceRecord></v01:createResourceRecord>";
static String createResourceRecordResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:createResourceRecordResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <guid xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">04063D9D54C6A01F</guid>\n"
+ " </ns1:createResourceRecordResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String updateResourceRecordResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:updateResourceRecordResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <result xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">Successful</result>\n"
+ " </ns1:updateResourceRecordResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String deleteResourceRecord =
"<v01:deleteResourceRecord><transactionID /><guid>ABCDEF</guid></v01:deleteResourceRecord>";
static String deleteResourceRecordResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:deleteResourceRecordResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <result xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">Successful</result>\n"
+ " </ns1:deleteResourceRecordResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
getLoadBalancingPoolsByZone =
"<v01:getLoadBalancingPoolsByZone><zoneName>denominator.io.</zoneName><lbPoolType>RR</lbPoolType></v01:getLoadBalancingPoolsByZone>";
static String getLoadBalancingPoolsByZoneResponseHeader =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getLoadBalancingPoolsByZoneResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <LBPoolList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">\n";
static String getLoadBalancingPoolsByZoneResponseFooter = " </LBPoolList>\n"
+ " </ns1:getLoadBalancingPoolsByZoneResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getLoadBalancingPoolsByZoneResponseAbsent =
getLoadBalancingPoolsByZoneResponseHeader
+ getLoadBalancingPoolsByZoneResponseFooter;
static String getRRPoolRecords =
"<v01:getRRPoolRecords><lbPoolId>000000000000002</lbPoolId></v01:getRRPoolRecords>";
static String getRRPoolRecordsResponseHeader =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getRRPoolRecordsResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <ResourceRecordList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">\n";
static String getRRPoolRecordsResponseFooter = " </ResourceRecordList>\n"
+ " </ns1:getRRPoolRecordsResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getRRPoolRecordsResponseAbsent =
getRRPoolRecordsResponseHeader + getRRPoolRecordsResponseFooter;
static String
addRRLBPool =
"<v01:addRRLBPool><transactionID /><zoneName>denominator.io.</zoneName><hostName>www.denominator.io.</hostName><description>1</description><poolRecordType>1</poolRecordType><rrGUID /></v01:addRRLBPool>";
static String addRRLBPoolResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:addRRLBPoolResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <RRPoolID>AAAAAAAAAAAAAAAA</RRPoolID>\n"
+ " </ns1:addRRLBPoolResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
addRecordToRRPool =
"<v01:addRecordToRRPool><transactionID /><roundRobinRecord lbPoolID=\"AAAAAAAAAAAAAAAA\" info1Value=\"www1.denominator.io.\" ZoneName=\"denominator.io.\" Type=\"1\" TTL=\"300\"/></v01:addRecordToRRPool>";
static String addRecordToRRPoolResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:addRecordToRRPoolResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <guid>012345</guid>\n"
+ " </ns1:addRecordToRRPoolResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
deleteLBPool =
"<v01:deleteLBPool><transactionID /><lbPoolID>AAAAAAAAAAAAAAAA</lbPoolID><DeleteAll>Yes</DeleteAll><retainRecordId /></v01:deleteLBPool>";
static String deleteLBPoolResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:deleteLBPoolResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <result xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">Successful</result>\n"
+ " </ns1:deleteLBPoolResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
getDirectionalPoolsOfZone =
"<v01:getDirectionalPoolsOfZone><zoneName>denominator.io.</zoneName></v01:getDirectionalPoolsOfZone>";
static String getDirectionalPoolsOfZoneResponseHeader =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getDirectionalPoolsOfZoneResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <DirectionalPoolList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">\n";
static String getDirectionalPoolsOfZoneResponseFooter = " </DirectionalPoolList>\n"
+ " </ns1:getDirectionalPoolsOfZoneResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getDirectionalPoolsOfZoneResponsePresent = getDirectionalPoolsOfZoneResponseHeader
+ " <ns2:DirectionalPoolData dirpoolid=\"D000000000000001\" Zoneid=\"Z000000000000001\" Pooldname=\"www.denominator.io.\" DirPoolType=\"GEOLOCATION\" Description=\"test with ips and cnames\" />\n"
+ " <ns2:DirectionalPoolData dirpoolid=\"D000000000000002\" Zoneid=\"Z000000000000001\" Pooldname=\"www2.denominator.io.\" DirPoolType=\"SOURCEIP\" Description=\"should filter out as not geo\" />\n"
+ getDirectionalPoolsOfZoneResponseFooter;
static String getDirectionalPoolsOfZoneResponseAbsent = getDirectionalPoolsOfZoneResponseHeader
+ getDirectionalPoolsOfZoneResponseFooter;
static String
getDirectionalDNSRecordsForHostTemplate =
"<v01:getDirectionalDNSRecordsForHost><zoneName>%s</zoneName><hostName>%s</hostName><poolRecordType>%s</poolRecordType></v01:getDirectionalDNSRecordsForHost>";
static String getDirectionalDNSRecordsForHost =
format(getDirectionalDNSRecordsForHostTemplate, "denominator.io.",
"www.denominator.io.", 0);
static String getDirectionalDNSRecordsForHostIPV4 =
format(getDirectionalDNSRecordsForHostTemplate,
"denominator.io.", "www.denominator.io.", 1);
static String getDirectionalDNSRecordsForHostIPV6 =
format(getDirectionalDNSRecordsForHostTemplate,
"denominator.io.", "www.denominator.io.", 28);
static String getDirectionalDNSRecordsForHostResponseHeader =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getDirectionalDNSRecordsForHostResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n";
static String getDirectionalDNSRecordsForHostResponseFooter =
" </ns1:getDirectionalDNSRecordsForHostResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getDirectionalDNSRecordsForHostResponsePresent =
getDirectionalDNSRecordsForHostResponseHeader
+ " <DirectionalDNSRecordDetailList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\" ZoneName=\"denominator.io.\" DName=\"www.denominator.io.\">\n"
+ " <ns2:DirectionalDNSRecordDetail GeolocationGroupName=\"Europe\" GeolocationGroupId=\"C000000000000001\" TerritoriesCount=\"54\" DirPoolRecordId=\"A000000000000001\">\n"
+ " <ns2:DirectionalDNSRecord recordType=\"CNAME\" TTL=\"300\" noResponseRecord=\"false\">\n"
+ " <ns2:InfoValues Info1Value=\"www-000000001.eu-west-1.elb.amazonaws.com.\" />\n"
+ " </ns2:DirectionalDNSRecord>\n"
+ " </ns2:DirectionalDNSRecordDetail>\n"
+ " <ns2:DirectionalDNSRecordDetail GeolocationGroupName=\"US\" GeolocationGroupId=\"C000000000000002\" TerritoriesCount=\"3\" DirPoolRecordId=\"A000000000000002\">\n"
+ " <ns2:DirectionalDNSRecord recordType=\"CNAME\" TTL=\"300\" noResponseRecord=\"false\">\n"
+ " <ns2:InfoValues Info1Value=\"www-000000001.us-east-1.elb.amazonaws.com.\" />\n"
+ " </ns2:DirectionalDNSRecord>\n"
+ " </ns2:DirectionalDNSRecordDetail>\n"
+ " <ns2:DirectionalDNSRecordDetail GeolocationGroupName=\"Everywhere Else\" GeolocationGroupId=\"C000000000000003\" TerritoriesCount=\"323\" DirPoolRecordId=\"A000000000000003\">\n"
+ " <ns2:DirectionalDNSRecord recordType=\"CNAME\" TTL=\"60\" noResponseRecord=\"false\">\n"
+ " <ns2:InfoValues Info1Value=\"www-000000002.us-east-1.elb.amazonaws.com.\" />\n"
+ " </ns2:DirectionalDNSRecord>\n"
+ " </ns2:DirectionalDNSRecordDetail>\n"
+ " </DirectionalDNSRecordDetailList>\n"
+ getDirectionalDNSRecordsForHostResponseFooter;
static String getDirectionalDNSRecordsForHostResponseAbsent =
getDirectionalDNSRecordsForHostResponseHeader
+ getDirectionalDNSRecordsForHostResponseFooter;
static String
getDirectionalDNSRecordsForGroupTemplate =
"<v01:getDirectionalDNSRecordsForGroup><groupName>%s</groupName><hostName>%s</hostName><zoneName>%s</zoneName><poolRecordType>%s</poolRecordType></v01:getDirectionalDNSRecordsForGroup>";
static String getDirectionalDNSRecordsForGroup =
format(getDirectionalDNSRecordsForGroupTemplate, "Europe",
"www.denominator.io.", "denominator.io.", 1);
static String getDirectionalDNSRecordsForGroupEuropeIPV6 =
format(getDirectionalDNSRecordsForGroupTemplate,
"Europe", "www.denominator.io.", "denominator.io.", 28);
static String getDirectionalDNSRecordsForGroupResponseHeader =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getDirectionalDNSRecordsForGroupResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n";
static String getDirectionalDNSRecordsForGroupResponseFooter =
" </ns1:getDirectionalDNSRecordsForGroupResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getDirectionalDNSRecordsForGroupResponsePresent =
getDirectionalDNSRecordsForGroupResponseHeader
+ " <DirectionalDNSRecordDetailList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\" ZoneName=\"denominator.io.\" DName=\"www.denominator.io.\">\n"
+ " <ns2:DirectionalDNSRecordDetail GeolocationGroupName=\"Europe\" GeolocationGroupId=\"C000000000000001\" TerritoriesCount=\"54\" DirPoolRecordId=\"A000000000000001\">\n"
+ " <ns2:DirectionalDNSRecord recordType=\"CNAME\" TTL=\"300\" noResponseRecord=\"false\">\n"
+ " <ns2:InfoValues Info1Value=\"www-000000001.eu-west-1.elb.amazonaws.com.\" />\n"
+ " </ns2:DirectionalDNSRecord>\n"
+ " </ns2:DirectionalDNSRecordDetail>\n"
+ " </DirectionalDNSRecordDetailList>\n"
+ getDirectionalDNSRecordsForGroupResponseFooter;
static String getDirectionalDNSRecordsForGroupResponseAbsent =
getDirectionalDNSRecordsForGroupResponseHeader
+ getDirectionalDNSRecordsForGroupResponseFooter;
static String
addDirectionalPool =
"<v01:addDirectionalPool><transactionID /><AddDirectionalPoolData dirPoolType=\"GEOLOCATION\" poolRecordType=\"A\" zoneName=\"denominator.io.\" hostName=\"www.denominator.io.\" description=\"A\"/></v01:addDirectionalPool>";
static String addDirectionalPoolResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:addDirectionalPoolResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <DirPoolID>AAAAAAAAAAAAAAAA</DirPoolID>\n"
+ " </ns1:addDirectionalPoolResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
deleteDirectionalPool =
"<v01:deleteDirectionalPool><transactionID /><dirPoolID>AAAAAAAAAAAAAAAA</dirPoolID><retainRecordID /></v01:deleteDirectionalPool>";
static String deleteDirectionalPoolResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:deleteDirectionalPoolResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <result xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">Successful</result>\n"
+ " </ns1:deleteDirectionalPoolResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
deleteDirectionalPoolRecord =
"<v01:deleteDirectionalPoolRecord><transactionID /><dirPoolRecordId>00000000000</dirPoolRecordId></v01:deleteDirectionalPoolRecord>";
static String deleteDirectionalPoolRecordResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:deleteDirectionalPoolRecordResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <result xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">Successful</result>\n"
+ " </ns1:deleteDirectionalPoolRecordResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String addDirectionalPoolRecord = "<v01:addDirectionalPoolRecord><transactionID />"
+ "<AddDirectionalRecordData directionalPoolId=\"AAAAAAAAAAAAAAAA\">"
+ "<DirectionalRecordConfiguration recordType=\"MX\" TTL=\"1800\" >"
+ "<InfoValues Info1Value=\"10\" Info2Value=\"maileast.denominator.io.\" />"
+ "</DirectionalRecordConfiguration>"
+ "<GeolocationGroupData><GroupData groupingType=\"DEFINE_NEW_GROUP\" />"
+ "<GeolocationGroupDetails groupName=\"Mexas\">"
+ "<GeolocationGroupDefinitionData regionName=\"United States (US)\" territoryNames=\"Maryland;Texas\" />"
+ "</GeolocationGroupDetails></GeolocationGroupData>"
+ "<forceOverlapTransfer>true</forceOverlapTransfer></AddDirectionalRecordData></v01:addDirectionalPoolRecord>";
static String addDirectionalPoolRecordResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:addDirectionalPoolRecordResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <DirectionalPoolRecordID xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">06063DC355058294</DirectionalPoolRecordID>\n"
+ " </ns1:addDirectionalPoolRecordResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
updateDirectionalPoolRecordTemplate =
"<v01:updateDirectionalPoolRecord><transactionID /><UpdateDirectionalRecordData directionalPoolRecordId=\"%s\"><DirectionalRecordConfiguration TTL=\"%s\" ><InfoValues Info1Value=\"%s\" /></DirectionalRecordConfiguration>%s</UpdateDirectionalRecordData></v01:updateDirectionalPoolRecord>";
static String updateDirectionalPoolRecordRegions = format(
updateDirectionalPoolRecordTemplate,
"A000000000000001",
300,
"www-000000001.eu-west-1.elb.amazonaws.com.",
"<GeolocationGroupDetails groupName=\"Europe\"><GeolocationGroupDefinitionData regionName=\"Europe\" territoryNames=\"Aland Islands\" /></GeolocationGroupDetails><forceOverlapTransfer>true</forceOverlapTransfer>");
static String updateDirectionalPoolRecordResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:updateDirectionalPoolRecordResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <result xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">Successful</result>\n"
+ " </ns1:updateDirectionalPoolRecordResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String
getDirectionalDNSGroupDetails =
"<v01:getDirectionalDNSGroupDetails><GroupId>AAAAAAAAAAAAAAAA</GroupId></v01:getDirectionalDNSGroupDetails>";
static String getDirectionalDNSGroupDetailsResponseEurope = "<?xml version=\"1.0\"?>\n"
+ "<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getDirectionalDNSGroupDetailsResponseEurope xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <DirectionalDNSGroupDetail xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\" GroupName=\"Europe\">\n"
+ " <ns2:DirectionalDNSRegion>\n"
+ " <ns2:RegionForNewGroups RegionName=\"Europe\"\n"
+ " TerritoryName=\"Aland Islands;Albania;Andorra;Armenia;Austria;Azerbaijan;Belarus;Belgium;Bosnia-Herzegovina;Bulgaria;Croatia;Czech Republic;Denmark;Estonia;Faroe Islands;Finland;France;Georgia;Germany;Gibraltar;Greece;Guernsey;Hungary;Iceland;Ireland;Isle of Man;Italy;Jersey;Latvia;Liechtenstein;Lithuania;Luxembourg;Macedonia, the former Yugoslav Republic of;Malta;Moldova, Republic of;Monaco;Montenegro;Netherlands;Norway;Poland;Portugal;Romania;San Marino;Serbia;Slovakia;Slovenia;Spain;Svalbard and Jan Mayen;Sweden;Switzerland;Ukraine;Undefined Europe;United Kingdom - England, Northern Ireland, Scotland, Wales;Vatican City\" />\n"
+ " </ns2:DirectionalDNSRegion>\n"
+ " </DirectionalDNSGroupDetail>\n"
+ " </ns1:getDirectionalDNSGroupDetailsResponseEurope>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getAvailableRegions = "<v01:getAvailableRegions />";
static String getAvailableRegionsResponse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ "<soap:Body>\n"
+ " <ns1:getAvailableRegionsResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <DirectionalDNSAvailableRegionList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">\n"
+ " <ns2:Region TerritoryName=\"Anonymous Proxy\" RegionName=\"Anonymous Proxy (A1)\" RegionID=\"14\" />\n"
+ " <ns2:Region TerritoryName=\"Antarctica;Bouvet Island;French Southern Territories\" RegionName=\"Antarctica\" RegionID=\"3\" />\n"
+ " </DirectionalDNSAvailableRegionList>\n"
+ " </ns1:getAvailableRegionsResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
static String getResourceRecordsOfZoneResponsePresent = getResourceRecordsOfZoneResponseHeader
+ " <ns2:ResourceRecord ZoneName=\"denominator.io.\" Type=\"1\" DName=\"www.denominator.io.\" TTL=\"3600\" Guid=\"04023A2507B6468F\" ZoneId=\"0000000000000001\" LName=\"www.denominator.io.\" Created=\"2010-10-02T16:57:16.000Z\" Modified=\"2011-09-27T23:49:21.000Z\">\n"
+ " <ns2:InfoValues Info1Value=\"1.2.3.4\"/>\n"
+ " </ns2:ResourceRecord>\n"
+ " <ns2:ResourceRecord ZoneName=\"denominator.io.\" Type=\"2\" DName=\"denominator.io.\" TTL=\"86400\" Guid=\"0B0338C2023F7969\" ZoneId=\"0000000000000001\" LName=\"denominator.io.\" Created=\"2009-10-12T12:02:23.000Z\" Modified=\"2009-10-12T12:02:23.000Z\">\n"
+ " <ns2:InfoValues Info1Value=\"pdns2.ultradns.net.\"/>\n"
+ " </ns2:ResourceRecord>\n"
+ getResourceRecordsOfZoneResponseFooter;
static String getLoadBalancingPoolsByZoneResponsePresent =
getLoadBalancingPoolsByZoneResponseHeader
+ " <ns2:LBPoolData zoneid=\"0000000000000001\">\n"
+ " <ns2:PoolData description=\"uswest1\" PoolId=\"000000000000002\" PoolType=\"RD\" PoolRecordType=\"A\" PoolDName=\"app-uswest1.denominator.io.\" ResponseMethod=\"RR\" />\n"
+ " </ns2:LBPoolData>\n"
+ " <ns2:LBPoolData zoneid=\"0000000000000001\">\n"
+ " <ns2:PoolData description=\"uswest2\" PoolId=\"000000000000003\" PoolType=\"RD\" PoolRecordType=\"A\" PoolDName=\"app-uswest2.denominator.io.\" ResponseMethod=\"RR\" />\n"
+ " </ns2:LBPoolData>\n"
+ getLoadBalancingPoolsByZoneResponseFooter;
static String getRRPoolRecordsResponsePresent = getRRPoolRecordsResponseHeader
+ " <ns2:ResourceRecord ZoneName=\"denominator.io.\" Type=\"1\" DName=\"www.denominator.io.\" TTL=\"3600\" Guid=\"04023A2507B6468F\" ZoneId=\"0000000000000001\" LName=\"www.denominator.io.\" Created=\"2010-10-02T16:57:16.000Z\" Modified=\"2011-09-27T23:49:21.000Z\">\n"
+ " <ns2:InfoValues Info1Value=\"1.2.3.4\"/>\n"
+ " </ns2:ResourceRecord>\n"
+ " <ns2:ResourceRecord ZoneName=\"denominator.io.\" Type=\"2\" DName=\"denominator.io.\" TTL=\"86400\" Guid=\"0B0338C2023F7969\" ZoneId=\"0000000000000001\" LName=\"denominator.io.\" Created=\"2009-10-12T12:02:23.000Z\" Modified=\"2009-10-12T12:02:23.000Z\">\n"
+ " <ns2:InfoValues Info1Value=\"pdns2.ultradns.net.\"/>\n"
+ " </ns2:ResourceRecord>\n"
+ getRRPoolRecordsResponseFooter;
static String getDirectionalDNSRecordsForHostResponseFiltersOutSourceIP =
getDirectionalDNSRecordsForHostResponseHeader
+ " <DirectionalDNSRecordDetailList xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\" ZoneName=\"denominator.io.\" DName=\"www.denominator.io.\">\n"
+ " <ns2:DirectionalDNSRecordDetail SourceIPGroupName=\"172.16.1.0/24\" SourceIPGroupId=\"C000000000000001\" TerritoriesCount=\"54\" DirPoolRecordId=\"A000000000000001\">\n"
+ " <ns2:DirectionalDNSRecord recordType=\"CNAME\" TTL=\"300\" noResponseRecord=\"false\">\n"
+ " <ns2:InfoValues Info1Value=\"www-000000001.eu-west-1.elb.amazonaws.com.\" />\n"
+ " </ns2:DirectionalDNSRecord>\n"
+ " </ns2:DirectionalDNSRecordDetail>\n"
+ " <ns2:DirectionalDNSRecordDetail GeolocationGroupName=\"US\" GeolocationGroupId=\"C000000000000002\" TerritoriesCount=\"3\" DirPoolRecordId=\"A000000000000002\">\n"
+ " <ns2:DirectionalDNSRecord recordType=\"CNAME\" TTL=\"300\" noResponseRecord=\"false\">\n"
+ " <ns2:InfoValues Info1Value=\"www-000000001.us-east-1.elb.amazonaws.com.\" />\n"
+ " </ns2:DirectionalDNSRecord>\n"
+ " </ns2:DirectionalDNSRecordDetail>\n"
+ " </DirectionalDNSRecordDetailList>\n"
+ getDirectionalDNSRecordsForHostResponseFooter;
}
| 122 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSGeoResourceRecordSetApiMockTest.java | package denominator.ultradns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import denominator.model.ResourceRecordSet;
import denominator.model.profile.Geo;
import denominator.model.rdata.CNAMEData;
import denominator.profile.GeoResourceRecordSetApi;
import static denominator.assertj.ModelAssertions.assertThat;
import static denominator.ultradns.UltraDNSException.DIRECTIONAL_NOT_ENABLED;
import static denominator.ultradns.UltraDNSTest.getAvailableRegions;
import static denominator.ultradns.UltraDNSTest.getAvailableRegionsResponse;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSGroupDetails;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSGroupDetailsResponseEurope;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForGroup;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForGroupEuropeIPV6;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForGroupResponseAbsent;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForGroupResponsePresent;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForHost;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForHostIPV4;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForHostIPV6;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForHostResponseAbsent;
import static denominator.ultradns.UltraDNSTest.getDirectionalDNSRecordsForHostResponsePresent;
import static denominator.ultradns.UltraDNSTest.getDirectionalPoolsOfZone;
import static denominator.ultradns.UltraDNSTest.getDirectionalPoolsOfZoneResponsePresent;
import static denominator.ultradns.UltraDNSTest.updateDirectionalPoolRecordRegions;
import static denominator.ultradns.UltraDNSTest.updateDirectionalPoolRecordResponse;
import static denominator.ultradns.UltraDNSTest.updateDirectionalPoolRecordTemplate;
import static java.lang.String.format;
public class UltraDNSGeoResourceRecordSetApiMockTest {
@Rule
public final MockUltraDNSServer server = new MockUltraDNSServer();
@Test
public void apiWhenUnsupported() throws Exception {
server.enqueueError(DIRECTIONAL_NOT_ENABLED,
"Directional feature not Enabled or Directional migration is not done.");
assertThat(server.connect().api().geoRecordSetsInZone("denominator.io.")).isNull();
server.assertSoapBody(getAvailableRegions);
}
@Test
public void listWhenPresent() throws Exception {
server.enqueue(new MockResponse().setBody(getAvailableRegionsResponse));
server.enqueue(new MockResponse().setBody(getDirectionalPoolsOfZoneResponsePresent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForHostResponsePresent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEurope));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEverywhereElse));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseUS));
GeoResourceRecordSetApi api = server.connect().api().geoRecordSetsInZone("denominator.io.");
Iterator<ResourceRecordSet<?>> iterator = api.iterator();
assertEurope(iterator.next());
assertEverywhereElse(iterator.next());
assertUS(iterator.next());
assertThat(iterator).isEmpty();
server.assertSoapBody(getAvailableRegions);
server.assertSoapBody(getDirectionalPoolsOfZone);
server.assertSoapBody(getDirectionalDNSRecordsForHost);
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000001"));
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000003"));
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000002"));
}
@Test
public void iterateByNameWhenPresent() throws Exception {
server.enqueue(new MockResponse().setBody(getAvailableRegionsResponse));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForHostResponsePresent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEurope));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEverywhereElse));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseUS));
GeoResourceRecordSetApi api = server.connect().api().geoRecordSetsInZone("denominator.io.");
Iterator<ResourceRecordSet<?>> iterator = api.iterateByName("www.denominator.io.");
assertEurope(iterator.next());
assertEverywhereElse(iterator.next());
assertUS(iterator.next());
assertThat(iterator).isEmpty();
server.assertSoapBody(getAvailableRegions);
server.assertSoapBody(getDirectionalDNSRecordsForHost);
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000001"));
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000003"));
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000002"));
}
@Test
public void iterateByNameAndTypeWhenPresent() throws Exception {
server.enqueue(new MockResponse().setBody(getAvailableRegionsResponse));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForHostResponsePresent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForHostResponseAbsent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEurope));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEverywhereElse));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseUS));
GeoResourceRecordSetApi api = server.connect().api().geoRecordSetsInZone("denominator.io.");
Iterator<ResourceRecordSet<?>>
iterator =
api.iterateByNameAndType("www.denominator.io.", "CNAME");
assertEurope(iterator.next());
assertEverywhereElse(iterator.next());
assertUS(iterator.next());
assertThat(iterator).isEmpty();
server.assertSoapBody(getAvailableRegions);
server.assertSoapBody(getDirectionalDNSRecordsForHostIPV4);
server.assertSoapBody(getDirectionalDNSRecordsForHostIPV6);
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000001"));
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000003"));
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000002"));
}
@Test
public void supportedRegionsCache() throws Exception {
server.enqueue(new MockResponse().setBody(getAvailableRegionsResponse));
GeoResourceRecordSetApi api = server.connect().api().geoRecordSetsInZone("denominator.io.");
assertThat(api.supportedRegions()).hasSize(2);
api.supportedRegions(); // cached
server.assertSoapBody(getAvailableRegions);
}
@Test
public void putWhenMatches() throws Exception {
server.enqueue(new MockResponse().setBody(getAvailableRegionsResponse));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForGroupResponsePresent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForGroupResponseAbsent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEurope));
GeoResourceRecordSetApi api = server.connect().api().geoRecordSetsInZone("denominator.io.");
api.put(europe);
server.assertSoapBody(getAvailableRegions);
server.assertSoapBody(getDirectionalDNSRecordsForGroup);
server.assertSoapBody(getDirectionalDNSRecordsForGroupEuropeIPV6);
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000001"));
}
@Test
public void putWhenRegionsDiffer() throws Exception {
server.enqueue(new MockResponse().setBody(getAvailableRegionsResponse));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForGroupResponsePresent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForGroupResponseAbsent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSGroupDetailsResponseEurope));
server.enqueue(new MockResponse().setBody(updateDirectionalPoolRecordResponse));
GeoResourceRecordSetApi api = server.connect().api().geoRecordSetsInZone("denominator.io.");
ResourceRecordSet<CNAMEData> lessOfEurope = ResourceRecordSet.<CNAMEData>builder()
.name(europe.name())
.type(europe.type())
.qualifier(europe.qualifier())
.ttl(europe.ttl())
.addAll(europe.records())
.geo(Geo.create(new LinkedHashMap<String, Collection<String>>() {
{
put("Europe", Arrays.asList("Aland Islands"));
}
})).build();
api.put(lessOfEurope);
server.assertSoapBody(getAvailableRegions);
server.assertSoapBody(getDirectionalDNSRecordsForGroup);
server.assertSoapBody(getDirectionalDNSRecordsForGroupEuropeIPV6);
server.assertSoapBody(
getDirectionalDNSGroupDetails.replace("AAAAAAAAAAAAAAAA", "C000000000000001"));
server.assertSoapBody(updateDirectionalPoolRecordRegions);
}
@Test
public void putWhenTTLDiffers() throws Exception {
server.enqueue(new MockResponse().setBody(getAvailableRegionsResponse));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForGroupResponsePresent));
server.enqueue(new MockResponse().setBody(getDirectionalDNSRecordsForGroupResponseAbsent));
server.enqueue(new MockResponse().setBody(updateDirectionalPoolRecordResponse));
GeoResourceRecordSetApi api = server.connect().api().geoRecordSetsInZone("denominator.io.");
ResourceRecordSet<CNAMEData> lessTTL = ResourceRecordSet.<CNAMEData>builder()
.name(europe.name())
.type(europe.type())
.qualifier(europe.qualifier())
.ttl(600)
.addAll(europe.records())
.geo(europe.geo()).build();
api.put(lessTTL);
server.assertSoapBody(getAvailableRegions);
server.assertSoapBody(getDirectionalDNSRecordsForGroup);
server.assertSoapBody(getDirectionalDNSRecordsForGroupEuropeIPV6);
server.assertSoapBody(format(
updateDirectionalPoolRecordTemplate,
"A000000000000001",
600,
"www-000000001.eu-west-1.elb.amazonaws.com.",
"<GeolocationGroupDetails groupName=\"Europe\"><GeolocationGroupDefinitionData regionName=\"Europe\" territoryNames=\"Aland Islands;Albania;Andorra;Armenia;Austria;Azerbaijan;Belarus;Belgium;Bosnia-Herzegovina;Bulgaria;Croatia;Czech Republic;Denmark;Estonia;Faroe Islands;Finland;France;Georgia;Germany;Gibraltar;Greece;Guernsey;Hungary;Iceland;Ireland;Isle of Man;Italy;Jersey;Latvia;Liechtenstein;Lithuania;Luxembourg;Macedonia, the former Yugoslav Republic of;Malta;Moldova, Republic of;Monaco;Montenegro;Netherlands;Norway;Poland;Portugal;Romania;San Marino;Serbia;Slovakia;Slovenia;Spain;Svalbard and Jan Mayen;Sweden;Switzerland;Ukraine;Undefined Europe;United Kingdom - England, Northern Ireland, Scotland, Wales;Vatican City\" /></GeolocationGroupDetails><forceOverlapTransfer>true</forceOverlapTransfer>"));
}
void assertUS(ResourceRecordSet<?> actual) {
assertThat(actual)
.hasName("www.denominator.io.")
.hasType("CNAME")
.hasQualifier("US")
.hasTtl(300)
.containsRegion("United States (US)", "Alabama", "Alaska", "Arizona", "Arkansas",
"Armed Forces Americas", "Armed Forces Europe, Middle East, and Canada",
"Armed Forces Pacific", "California", "Colorado", "Connecticut", "Delaware",
"District of Columbia", "Florida", "Georgia", "Hawaii", "Idaho", "Illinois",
"Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland",
"Massachusetts", "Michigan", "Minnesota", "Mississippi", "Missouri",
"Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey",
"New Mexico", "New York", "North Carolina", "North Dakota", "Ohio",
"Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina",
"South Dakota", "Tennessee", "Texas", "Undefined United States",
"United States Minor Outlying Islands", "Utah", "Vermont", "Virginia",
"Washington", "West Virginia", "Wisconsin", "Wyoming")
.containsExactlyRecords(CNAMEData.create("www-000000001.us-east-1.elb.amazonaws.com."));
}
void assertEurope(ResourceRecordSet<?> actual) {
assertThat(actual).isEqualTo(europe);
}
void assertEverywhereElse(ResourceRecordSet<?> actual) {
assertThat(actual)
.hasName("www.denominator.io.")
.hasType("CNAME")
.hasQualifier("Everywhere Else")
.hasTtl(60)
.containsRegion("Anonymous Proxy (A1)", "Anonymous Proxy")
.containsRegion("Mexico", "Mexico")
.containsRegion("Satellite Provider (A2)", "Satellite Provider")
.containsRegion("Unknown / Uncategorized IPs", "Unknown / Uncategorized IPs")
.containsRegion("Canada (CA)", "Alberta", "British Columbia", "Greenland", "Manitoba",
"New Brunswick", "Newfoundland and Labrador", "Northwest Territories",
"Nova Scotia", "Nunavut", "Ontario", "Prince Edward Island", "Quebec",
"Saint Pierre and Miquelon", "Saskatchewan", "Undefined Canada", "Yukon")
.containsRegion("The Caribbean", "Anguilla", "Antigua and Barbuda", "Aruba", "Bahamas",
"Barbados", "Bermuda", "British Virgin Islands", "Cayman Islands", "Cuba",
"Dominica", "Dominican Republic", "Grenada", "Guadeloupe", "Haiti",
"Jamaica", "Martinique", "Montserrat", "Netherlands Antilles",
"Puerto Rico", "Saint Barthelemy", "Saint Martin",
"Saint Vincent and the Grenadines", "St. Kitts and Nevis", "St. Lucia",
"Trinidad and Tobago", "Turks and Caicos Islands", "U.S. Virgin Islands")
.containsRegion("Central America", "Belize", "Costa Rica", "El Salvador", "Guatemala",
"Honduras", "Nicaragua", "Panama", "Undefined Central America")
.containsRegion("South America", "Argentina", "Bolivia", "Brazil", "Chile", "Colombia",
"Ecuador", "Falkland Islands", "French Guiana", "Guyana", "Paraguay",
"Peru", "South Georgia and the South Sandwich Islands", "Suriname",
"Undefined South America", "Uruguay", "Venezuela, Bolivarian Republic of")
.containsRegion("Russian Federation", "Russian Federation")
.containsRegion("Middle East", "Afghanistan", "Bahrain", "Cyprus", "Iran", "Iraq", "Israel",
"Jordan", "Kuwait", "Lebanon", "Oman", "Palestinian Territory, Occupied",
"Qatar", "Saudi Arabia", "Syrian Arab Republic", "Turkey, Republic of",
"Undefined Middle East", "United Arab Emirates", "Yemen")
.containsRegion("Africa", "Algeria", "Angola", "Benin", "Botswana", "Burkina Faso",
"Burundi", "Cameroon", "Cape Verde", "Central African Republic", "Chad",
"Comoros", "Congo", "Cote d'Ivoire", "Democratic Republic of the Congo",
"Djibouti", "Egypt", "Equatorial Guinea", "Eritrea", "Ethiopia", "Gabon",
"Gambia", "Ghana", "Guinea", "Guinea-Bissau", "Kenya", "Lesotho", "Liberia",
"Libyan Arab Jamahiriya", "Madagascar", "Malawi", "Mali", "Mauritania",
"Mauritius", "Mayotte", "Morocco", "Mozambique", "Namibia", "Niger",
"Nigeria", "Reunion", "Rwanda", "Sao Tome and Principe", "Senegal",
"Seychelles", "Sierra Leone", "Somalia", "South Africa", "St. Helena",
"Sudan", "Swaziland", "Tanzania, United Republic of", "Togo", "Tunisia",
"Uganda", "Undefined Africa", "Western Sahara", "Zambia", "Zimbabwe")
.containsRegion("Asia", "Bangladesh", "Bhutan",
"British Indian Ocean Territory - Chagos Islands", "Brunei Darussalam",
"Cambodia", "China", "Hong Kong", "India", "Indonesia", "Japan",
"Kazakhstan", "Korea, Democratic People's Republic of",
"Korea, Republic of", "Kyrgyzstan", "Lao People's Democratic Republic",
"Macao", "Malaysia", "Maldives", "Mongolia", "Myanmar", "Nepal", "Pakistan",
"Philippines", "Singapore", "Sri Lanka", "Taiwan", "Tajikistan", "Thailand",
"Timor-Leste, Democratic Republic of", "Turkmenistan", "Undefined Asia",
"Uzbekistan", "Vietnam")
.containsRegion("Australia / Oceania", "American Samoa", "Australia", "Christmas Island",
"Cocos (Keeling) Islands", "Cook Islands", "Fiji", "French Polynesia",
"Guam", "Heard Island and McDonald Islands", "Kiribati", "Marshall Islands",
"Micronesia , Federated States of", "Nauru", "New Caledonia", "New Zealand",
"Niue", "Norfolk Island", "Northern Mariana Islands, Commonwealth of",
"Palau", "Papua New Guinea", "Pitcairn", "Samoa", "Solomon Islands",
"Tokelau", "Tonga", "Tuvalu", "Undefined Australia / Oceania", "Vanuatu",
"Wallis and Futuna")
.containsRegion("Antarctica", "Antarctica", "Bouvet Island", "French Southern Territories")
.containsExactlyRecords(
CNAMEData.create("www-000000002.us-east-1.elb.amazonaws.com."));
}
ResourceRecordSet<CNAMEData> europe = ResourceRecordSet
.<CNAMEData>builder()
.name("www.denominator.io.")
.type("CNAME")
.qualifier("Europe")
.ttl(300)
.add(CNAMEData.create("www-000000001.eu-west-1.elb.amazonaws.com."))
.geo(Geo.create(new LinkedHashMap<String, Collection<String>>() {
{
put("Europe", Arrays
.asList("Aland Islands", "Albania", "Andorra", "Armenia", "Austria", "Azerbaijan",
"Belarus", "Belgium", "Bosnia-Herzegovina", "Bulgaria", "Croatia",
"Czech Republic", "Denmark", "Estonia", "Faroe Islands", "Finland", "France",
"Georgia", "Germany", "Gibraltar", "Greece", "Guernsey", "Hungary", "Iceland",
"Ireland", "Isle of Man", "Italy", "Jersey", "Latvia", "Liechtenstein",
"Lithuania", "Luxembourg", "Macedonia, the former Yugoslav Republic of",
"Malta", "Moldova, Republic of", "Monaco", "Montenegro", "Netherlands",
"Norway", "Poland", "Portugal", "Romania", "San Marino", "Serbia", "Slovakia",
"Slovenia", "Spain", "Svalbard and Jan Mayen", "Sweden", "Switzerland",
"Ukraine", "Undefined Europe",
"United Kingdom - England, Northern Ireland, Scotland, Wales",
"Vatican City"));
}
})).build();
String getDirectionalDNSGroupDetailsResponseEverywhereElse =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getDirectionalDNSGroupDetailsResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <DirectionalDNSGroupDetail xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\" GroupName=\"Everywhere Else\">\n"
+ " <ns2:DirectionalDNSRegion>\n"
+ " <ns2:RegionForNewGroups RegionName=\"Anonymous Proxy (A1)\" TerritoryName=\"Anonymous Proxy\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Mexico\" TerritoryName=\"Mexico\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Satellite Provider (A2)\" TerritoryName=\"Satellite Provider\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Unknown / Uncategorized IPs\" TerritoryName=\"Unknown / Uncategorized IPs\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Canada (CA)\" TerritoryName=\"Alberta;British Columbia;Greenland;Manitoba;New Brunswick;Newfoundland and Labrador;Northwest Territories;Nova Scotia;Nunavut;Ontario;Prince Edward Island;Quebec;Saint Pierre and Miquelon;Saskatchewan;Undefined Canada;Yukon\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"The Caribbean\" TerritoryName=\"Anguilla;Antigua and Barbuda;Aruba;Bahamas;Barbados;Bermuda;British Virgin Islands;Cayman Islands;Cuba;Dominica;Dominican Republic;Grenada;Guadeloupe;Haiti;Jamaica;Martinique;Montserrat;Netherlands Antilles;Puerto Rico;Saint Barthelemy;Saint Martin;Saint Vincent and the Grenadines;St. Kitts and Nevis;St. Lucia;Trinidad and Tobago;Turks and Caicos Islands;U.S. Virgin Islands\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Central America\" TerritoryName=\"Belize;Costa Rica;El Salvador;Guatemala;Honduras;Nicaragua;Panama;Undefined Central America\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"South America\" TerritoryName=\"Argentina;Bolivia;Brazil;Chile;Colombia;Ecuador;Falkland Islands;French Guiana;Guyana;Paraguay;Peru;South Georgia and the South Sandwich Islands;Suriname;Undefined South America;Uruguay;Venezuela, Bolivarian Republic of\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Russian Federation\" TerritoryName=\"Russian Federation\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Middle East\" TerritoryName=\"Afghanistan;Bahrain;Cyprus;Iran;Iraq;Israel;Jordan;Kuwait;Lebanon;Oman;Palestinian Territory, Occupied;Qatar;Saudi Arabia;Syrian Arab Republic;Turkey, Republic of;Undefined Middle East;United Arab Emirates;Yemen\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Africa\" TerritoryName=\"Algeria;Angola;Benin;Botswana;Burkina Faso;Burundi;Cameroon;Cape Verde;Central African Republic;Chad;Comoros;Congo;Cote d'Ivoire;Democratic Republic of the Congo;Djibouti;Egypt;Equatorial Guinea;Eritrea;Ethiopia;Gabon;Gambia;Ghana;Guinea;Guinea-Bissau;Kenya;Lesotho;Liberia;Libyan Arab Jamahiriya;Madagascar;Malawi;Mali;Mauritania;Mauritius;Mayotte;Morocco;Mozambique;Namibia;Niger;Nigeria;Reunion;Rwanda;Sao Tome and Principe;Senegal;Seychelles;Sierra Leone;Somalia;South Africa;St. Helena;Sudan;Swaziland;Tanzania, United Republic of;Togo;Tunisia;Uganda;Undefined Africa;Western Sahara;Zambia;Zimbabwe\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Asia\" TerritoryName=\"Bangladesh;Bhutan;British Indian Ocean Territory - Chagos Islands;Brunei Darussalam;Cambodia;China;Hong Kong;India;Indonesia;Japan;Kazakhstan;Korea, Democratic People's Republic of;Korea, Republic of;Kyrgyzstan;Lao People's Democratic Republic;Macao;Malaysia;Maldives;Mongolia;Myanmar;Nepal;Pakistan;Philippines;Singapore;Sri Lanka;Taiwan;Tajikistan;Thailand;Timor-Leste, Democratic Republic of;Turkmenistan;Undefined Asia;Uzbekistan;Vietnam\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Australia / Oceania\" TerritoryName=\"American Samoa;Australia;Christmas Island;Cocos (Keeling) Islands;Cook Islands;Fiji;French Polynesia;Guam;Heard Island and McDonald Islands;Kiribati;Marshall Islands;Micronesia , Federated States of;Nauru;New Caledonia;New Zealand;Niue;Norfolk Island;Northern Mariana Islands, Commonwealth of;Palau;Papua New Guinea;Pitcairn;Samoa;Solomon Islands;Tokelau;Tonga;Tuvalu;Undefined Australia / Oceania;Vanuatu;Wallis and Futuna\" />\n"
+ " <ns2:RegionForNewGroups RegionName=\"Antarctica\" TerritoryName=\"Antarctica;Bouvet Island;French Southern Territories\" />\n"
+ " </ns2:DirectionalDNSRegion>\n"
+ " </DirectionalDNSGroupDetail>\n"
+ " </ns1:getDirectionalDNSGroupDetailsResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
String getDirectionalDNSGroupDetailsResponseUS =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n"
+ " <soap:Body>\n"
+ " <ns1:getDirectionalDNSGroupDetailsResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <DirectionalDNSGroupDetail\n"
+ " xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\" GroupName=\"US\">\n"
+ " <ns2:DirectionalDNSRegion>\n"
+ " <ns2:RegionForNewGroups RegionName=\"United States (US)\" TerritoryName=\"Alabama;Alaska;Arizona;Arkansas;Armed Forces Americas;Armed Forces Europe, Middle East, and Canada;Armed Forces Pacific;California;Colorado;Connecticut;Delaware;District of Columbia;Florida;Georgia;Hawaii;Idaho;Illinois;Indiana;Iowa;Kansas;Kentucky;Louisiana;Maine;Maryland;Massachusetts;Michigan;Minnesota;Mississippi;Missouri;Montana;Nebraska;Nevada;New Hampshire;New Jersey;New Mexico;New York;North Carolina;North Dakota;Ohio;Oklahoma;Oregon;Pennsylvania;Rhode Island;South Carolina;South Dakota;Tennessee;Texas;Undefined United States;United States Minor Outlying Islands;Utah;Vermont;Virginia;Washington;West Virginia;Wisconsin;Wyoming\" />\n"
+ " </ns2:DirectionalDNSRegion>\n"
+ " </DirectionalDNSGroupDetail>\n"
+ " </ns1:getDirectionalDNSGroupDetailsResponse>\n"
+ " </soap:Body>\n"
+ "</soap:Envelope>";
}
| 123 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSConnection.java | package denominator.ultradns;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
import denominator.DNSApiManager;
import denominator.Denominator;
import feign.Logger;
import static denominator.CredentialsConfiguration.credentials;
import static feign.Util.emptyToNull;
import static java.lang.System.getProperty;
public class UltraDNSConnection {
final DNSApiManager manager;
final String mutableZone;
UltraDNSConnection() {
String username = emptyToNull(getProperty("ultradns.username"));
String password = emptyToNull(getProperty("ultradns.password"));
if (username != null && password != null) {
manager = create(username, password);
} else {
manager = null;
}
mutableZone = emptyToNull(getProperty("ultradns.zone"));
}
static DNSApiManager create(String username, String password) {
UltraDNSProvider provider = new UltraDNSProvider(emptyToNull(getProperty("ultradns.url")));
return Denominator.create(provider, credentials(username, password), new Overrides());
}
@Module(overrides = true, library = true)
static class Overrides {
@Provides
@Singleton
Logger.Level provideLevel() {
return Logger.Level.FULL;
}
@Provides
@Singleton
Logger provideLogger() {
return new Logger.JavaLogger().appendToFile("build/http-wire.log");
}
}
}
| 124 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSResourceRecordSetApiMockTest.java | package denominator.ultradns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import java.util.Arrays;
import denominator.ResourceRecordSetApi;
import static denominator.assertj.ModelAssertions.assertThat;
import static denominator.model.ResourceRecordSets.a;
import static denominator.model.ResourceRecordSets.aaaa;
import static denominator.ultradns.UltraDNSException.POOL_ALREADY_EXISTS;
import static denominator.ultradns.UltraDNSTest.deleteLBPool;
import static denominator.ultradns.UltraDNSTest.deleteLBPoolResponse;
import static denominator.ultradns.UltraDNSTest.deleteResourceRecord;
import static denominator.ultradns.UltraDNSTest.deleteResourceRecordResponse;
import static denominator.ultradns.UltraDNSTest.getLoadBalancingPoolsByZone;
import static denominator.ultradns.UltraDNSTest.getLoadBalancingPoolsByZoneResponseFooter;
import static denominator.ultradns.UltraDNSTest.getLoadBalancingPoolsByZoneResponseHeader;
import static denominator.ultradns.UltraDNSTest.getRRPoolRecords;
import static denominator.ultradns.UltraDNSTest.getRRPoolRecordsResponseAbsent;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfDNameByType;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfDNameByTypeResponseFooter;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfDNameByTypeResponseHeader;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfZone;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfZoneResponseAbsent;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfZoneResponseFooter;
import static denominator.ultradns.UltraDNSTest.getResourceRecordsOfZoneResponseHeader;
import static java.lang.String.format;
public class UltraDNSResourceRecordSetApiMockTest {
@Rule
public final MockUltraDNSServer server = new MockUltraDNSServer();
static String
getResourceRecordsOfDNameByTypeAll =
getResourceRecordsOfDNameByType.replace("<rrType>6</rrType>",
"<rrType>0</rrType>")
.replace("<hostName>denominator.io.", "<hostName>www.denominator.io.");
static String
aRecordTTLGuidAddressTemplate =
"<ns2:ResourceRecord ZoneName=\"denominator.io.\" Type=\"1\" DName=\"www.denominator.io.\" TTL=\"%d\" Guid=\"%s\" ZoneId=\"0000000000000001\" LName=\"www.denominator.io.\" Created=\"2009-10-12T12:02:23.000Z\" Modified=\"2011-09-27T23:49:22.000Z\"><ns2:InfoValues Info1Value=\"%s\"/></ns2:ResourceRecord>";
static String records1And2 = new StringBuilder(getResourceRecordsOfZoneResponseHeader)
.append(format(aRecordTTLGuidAddressTemplate, 3600, "AAAAAAAAAAAA", "192.0.2.1"))
.append(format(aRecordTTLGuidAddressTemplate, 3600, "BBBBBBBBBBBB", "198.51.100.1"))
.append(getResourceRecordsOfZoneResponseFooter).toString();
static String
getResourceRecordsOfDNameByTypeA =
getResourceRecordsOfDNameByTypeAll.replace("<rrType>0</rrType>", "<rrType>1</rrType>");
static String
addRRLBPoolTemplate =
"<v01:addRRLBPool><transactionID /><zoneName>denominator.io.</zoneName><hostName>www.denominator.io.</hostName><description>%s</description><poolRecordType>%s</poolRecordType><rrGUID /></v01:addRRLBPool>";
static String
addRRLBPoolResponseTemplate =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"><soap:Body><ns1:addRRLBPoolResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\"><RRPoolID xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">%s</RRPoolID></ns1:addRRLBPoolResponse></soap:Body></soap:Envelope>";
static String
addRecordToRRPoolTemplate =
"<v01:addRecordToRRPool><transactionID /><roundRobinRecord lbPoolID=\"%s\" info1Value=\"%s\" ZoneName=\"denominator.io.\" Type=\"%s\" TTL=\"%s\"/></v01:addRecordToRRPool>";
static String
addRecordToRRPoolResponseTemplate =
"<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"><soap:Body><ns1:addRecordToRRPoolResponse xmlns:ns1=\"http://webservice.api.ultra.neustar.com/v01/\"><guid xmlns:ns2=\"http://schema.ultraservice.neustar.com/v01/\">%s</guid></ns1:addRecordToRRPoolResponse></soap:Body></soap:Envelope>";
static String poolIDTypeTemplate = " <ns2:LBPoolData zoneid=\"0000000000000001\">\n"
+ " <ns2:PoolData description=\"foo\" PoolId=\"%s\" PoolType=\"RD\" PoolRecordType=\"%s\" PoolDName=\"www.denominator.io.\" ResponseMethod=\"RR\" />\n"
+ " </ns2:LBPoolData>\n";
static String poolsForAandAAAA = new StringBuilder(getLoadBalancingPoolsByZoneResponseHeader)
.append(format(poolIDTypeTemplate, "1111A", "A"))
.append(format(poolIDTypeTemplate, "1111AAAA", "AAAA"))
.append(getLoadBalancingPoolsByZoneResponseFooter).toString();
static String record1 = getResourceRecordsOfDNameByTypeResponseHeader
+ " <ns2:ResourceRecord ZoneName=\"denominator.io.\" Type=\"6\" DName=\"www.denominator.io.\" TTL=\"3600\" Guid=\"ABCDEF\" ZoneId=\"03053D8E57C7A22A\" LName=\"www.denominator.io.\" Created=\"2013-02-22T08:22:48.000Z\" Modified=\"2013-02-22T08:22:49.000Z\">\n"
+ " <ns2:InfoValues Info1Value=\"192.0.2.1\" />\n"
+ " </ns2:ResourceRecord>\n"
+ getResourceRecordsOfDNameByTypeResponseFooter;
@Test
public void listWhenNoneMatch() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
assertThat(api.iterator()).isEmpty();
server.assertSoapBody(getResourceRecordsOfZone);
}
@Test
public void iterateByNameWhenNoneMatch() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
assertThat(api.iterateByName("www.denominator.io.")).isEmpty();
server.assertSoapBody(getResourceRecordsOfDNameByTypeAll);
}
@Test
public void iterateByNameWhenMatch() throws Exception {
server.enqueue(new MockResponse().setBody(records1And2));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
assertThat(api.iterateByName("www.denominator.io."))
.containsExactly(
a("www.denominator.io.", 3600, Arrays.asList("192.0.2.1", "198.51.100.1")));
server.assertSoapBody(getResourceRecordsOfDNameByTypeAll);
}
@Test
public void getByNameAndTypeWhenAbsent() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
assertThat(api.getByNameAndType("www.denominator.io.", "A")).isNull();
server.assertSoapBody(getResourceRecordsOfDNameByTypeA);
}
@Test
public void getByNameAndTypeWhenPresent() throws Exception {
server.enqueue(new MockResponse().setBody(records1And2));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
assertThat(api.getByNameAndType("www.denominator.io.", "A"))
.isEqualTo(a("www.denominator.io.", 3600, Arrays.asList("192.0.2.1", "198.51.100.1")));
server.assertSoapBody(getResourceRecordsOfDNameByTypeA);
}
@Test
public void putFirstACreatesRoundRobinPoolThenAddsRecordToIt() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
server.enqueue(new MockResponse().setBody(format(addRRLBPoolResponseTemplate, "1111A")));
server.enqueue(
new MockResponse().setBody(format(addRecordToRRPoolResponseTemplate, "AAAAAAAAAAAA")));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
api.put(a("www.denominator.io.", 3600, "192.0.2.1"));
server.assertSoapBody(getResourceRecordsOfDNameByTypeA);
server.assertSoapBody(format(addRRLBPoolTemplate, "1", "1"));
server.assertSoapBody(format(addRecordToRRPoolTemplate, "1111A", "192.0.2.1", "1", 3600));
}
@Test
public void putFirstAReusesExistingEmptyRoundRobinPool()
throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
server.enqueueError(POOL_ALREADY_EXISTS,
"Pool already created for this host name : www.denominator.io.");
server.enqueue(new MockResponse().setBody(poolsForAandAAAA));
server.enqueue(
new MockResponse().setBody(format(addRecordToRRPoolResponseTemplate, "AAAAAAAAAAAA")));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
api.put(a("www.denominator.io.", 3600, "192.0.2.1"));
server.assertSoapBody(getResourceRecordsOfDNameByTypeA);
server.assertSoapBody(format(addRRLBPoolTemplate, "1", "1"));
server.assertSoapBody(getLoadBalancingPoolsByZone);
server.assertSoapBody(format(addRecordToRRPoolTemplate, "1111A", "192.0.2.1", "1", 3600));
}
@Test
public void deleteAlsoRemovesPool() throws Exception {
server.enqueue(new MockResponse().setBody(record1));
server.enqueue(new MockResponse().setBody(deleteResourceRecordResponse));
server.enqueue(new MockResponse().setBody(poolsForAandAAAA));
server.enqueue(new MockResponse().setBody(getRRPoolRecordsResponseAbsent));
server.enqueue(new MockResponse().setBody(deleteLBPoolResponse));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
api.deleteByNameAndType("www.denominator.io.", "A");
server.assertSoapBody(getResourceRecordsOfDNameByTypeA);
server.assertSoapBody(deleteResourceRecord);
server.assertSoapBody(getLoadBalancingPoolsByZone);
server.assertSoapBody(getRRPoolRecords.replace("000000000000002", "1111A"));
server.assertSoapBody(deleteLBPool.replace("AAAAAAAAAAAAAAAA", "1111A"));
}
@Test
public void putSecondAAddsRecordToExistingPool() throws Exception {
server.enqueue(new MockResponse().setBody(record1));
server.enqueueError(POOL_ALREADY_EXISTS,
"Pool already created for this host name : www.denominator.io.");
server.enqueue(new MockResponse().setBody(poolsForAandAAAA));
server.enqueue(
new MockResponse().setBody(format(addRecordToRRPoolResponseTemplate, "BBBBBBBBBBBB")));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
api.put(a("www.denominator.io.", 3600, Arrays.asList("192.0.2.1", "198.51.100.1")));
server.assertSoapBody(getResourceRecordsOfDNameByTypeA);
server.assertSoapBody(format(addRRLBPoolTemplate, "1", "1"));
server.assertSoapBody(getLoadBalancingPoolsByZone);
server.assertSoapBody(
format(addRecordToRRPoolTemplate, "1111A", "198.51.100.1", "1", 3600));
}
@Test
public void putFirstAAAACreatesRoundRobinPoolThenAddsRecordToIt() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
server.enqueue(new MockResponse().setBody(format(addRRLBPoolResponseTemplate, "1111AAAA")));
server.enqueue(
new MockResponse().setBody(format(addRecordToRRPoolResponseTemplate, "AAAAAAAAAAAA")));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
api.put(aaaa("www.denominator.io.", 3600, "2001:0DB8:85A3:0000:0000:8A2E:0370:7334"));
server.assertSoapBody(getResourceRecordsOfDNameByTypeAll
.replace("<rrType>0</rrType>", "<rrType>28</rrType>"));
server.assertSoapBody(format(addRRLBPoolTemplate, "28", "28"));
server.assertSoapBody(
format(addRecordToRRPoolTemplate, "1111AAAA", "2001:0DB8:85A3:0000:0000:8A2E:0370:7334",
"28", 3600));
}
@Test
public void putFirstAAAAReusesExistingEmptyRoundRobinPool() throws Exception {
server.enqueue(new MockResponse().setBody(getResourceRecordsOfZoneResponseAbsent));
server.enqueueError(POOL_ALREADY_EXISTS,
"Pool already created for this host name : www.denominator.io.");
server.enqueue(new MockResponse().setBody(poolsForAandAAAA));
server.enqueue(
new MockResponse().setBody(format(addRecordToRRPoolResponseTemplate, "AAAAAAAAAAAA")));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone("denominator.io.");
api.put(aaaa("www.denominator.io.", 3600, "2001:0DB8:85A3:0000:0000:8A2E:0370:7334"));
server.assertSoapBody(getResourceRecordsOfDNameByTypeAll
.replace("<rrType>0</rrType>", "<rrType>28</rrType>"));
server.assertSoapBody(format(addRRLBPoolTemplate, "28", "28"));
server.assertSoapBody(getLoadBalancingPoolsByZone);
server.assertSoapBody(
format(addRecordToRRPoolTemplate, "1111AAAA", "2001:0DB8:85A3:0000:0000:8A2E:0370:7334",
"28", 3600));
}
}
| 125 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSCheckConnectionLiveTest.java | package denominator.ultradns;
import denominator.CheckConnectionLiveTest;
import denominator.Live.UseTestGraph;
@UseTestGraph(UltraDNSTestGraph.class)
public class UltraDNSCheckConnectionLiveTest extends CheckConnectionLiveTest {
}
| 126 |
0 | Create_ds/denominator/ultradns/src/test/java/denominator | Create_ds/denominator/ultradns/src/test/java/denominator/ultradns/UltraDNSReadOnlyLiveTest.java | package denominator.ultradns;
import denominator.Live.UseTestGraph;
import denominator.ReadOnlyLiveTest;
@UseTestGraph(UltraDNSTestGraph.class)
public class UltraDNSReadOnlyLiveTest extends ReadOnlyLiveTest {
}
| 127 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/GroupGeoRecordByNameTypeIterator.java | package denominator.ultradns;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.inject.Inject;
import denominator.common.PeekingIterator;
import denominator.model.ResourceRecordSet;
import denominator.model.ResourceRecordSet.Builder;
import denominator.model.profile.Geo;
import denominator.ultradns.UltraDNS.DirectionalRecord;
import static denominator.common.Util.peekingIterator;
import static denominator.common.Util.toMap;
/**
* Generally, this iterator will produce {@link ResourceRecordSet} for only a single record type.
* However, there are special cases where this can produce multiple. For example, {@link
* DirectionalPool.RecordType#IPV4} and {@link DirectionalPool.RecordType#IPV6} emit both address
* ({@code A} or {@code AAAA}) and {@code CNAME} records.
*/
class GroupGeoRecordByNameTypeIterator implements Iterator<ResourceRecordSet<?>> {
private final Map<String, Geo> cache = new LinkedHashMap<String, Geo>();
private final UltraDNS api;
private final PeekingIterator<DirectionalRecord> peekingIterator;
private GroupGeoRecordByNameTypeIterator(UltraDNS api,
Iterator<DirectionalRecord> sortedIterator) {
this.api = api;
this.peekingIterator = peekingIterator(sortedIterator);
}
static boolean typeTTLAndGeoGroupEquals(DirectionalRecord actual, DirectionalRecord expected) {
return actual.type.equals(expected.type) && actual.ttl == expected.ttl
&& actual.geoGroupId.equals(expected.geoGroupId);
}
/**
* skips no response records as they aren't portable
*/
@Override
public boolean hasNext() {
if (!peekingIterator.hasNext()) {
return false;
}
DirectionalRecord record = peekingIterator.peek();
if (record.noResponseRecord) {
// TODO: log as this is unsupported
peekingIterator.next();
}
return true;
}
@Override
public ResourceRecordSet<?> next() {
DirectionalRecord record = peekingIterator.next();
Builder<Map<String, Object>>
builder =
ResourceRecordSet.builder().name(record.name).type(record.type)
.qualifier(record.geoGroupName).ttl(record.ttl);
builder.add(toMap(record.type, record.rdata));
if (!cache.containsKey(record.geoGroupId)) {
Geo
profile =
Geo.create(api.getDirectionalDNSGroupDetails(record.geoGroupId).regionToTerritories);
cache.put(record.geoGroupId, profile);
}
builder.geo(cache.get(record.geoGroupId));
while (hasNext()) {
DirectionalRecord next = peekingIterator.peek();
if (typeTTLAndGeoGroupEquals(next, record)) {
peekingIterator.next();
builder.add(toMap(record.type, next.rdata));
} else {
break;
}
}
return builder.build();
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
static final class Factory {
private final UltraDNS api;
@Inject
Factory(UltraDNS api) {
this.api = api;
}
/**
* @param sortedIterator only contains records with the same {@link DirectionalRecord#name()},
* sorted by {@link DirectionalRecord#type()}, {@link
* DirectionalRecord#getGeolocationGroup()} or {@link
* DirectionalRecord#group()}
*/
Iterator<ResourceRecordSet<?>> create(Iterator<DirectionalRecord> sortedIterator) {
return new GroupGeoRecordByNameTypeIterator(api, sortedIterator);
}
}
}
| 128 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/GroupByRecordNameAndTypeIterator.java | package denominator.ultradns;
import java.util.Iterator;
import java.util.Map;
import denominator.ResourceTypeToValue;
import denominator.common.PeekingIterator;
import denominator.model.ResourceRecordSet;
import denominator.model.ResourceRecordSet.Builder;
import denominator.ultradns.UltraDNS.Record;
import static denominator.common.Util.peekingIterator;
import static denominator.common.Util.toMap;
class GroupByRecordNameAndTypeIterator implements Iterator<ResourceRecordSet<?>> {
private final PeekingIterator<Record> peekingIterator;
public GroupByRecordNameAndTypeIterator(Iterator<Record> sortedIterator) {
this.peekingIterator = peekingIterator(sortedIterator);
}
static boolean fqdnAndTypeEquals(Record actual, Record expected) {
return actual.name.equals(expected.name) && actual.typeCode == expected.typeCode;
}
@Override
public boolean hasNext() {
return peekingIterator.hasNext();
}
@Override
public ResourceRecordSet<?> next() {
Record record = peekingIterator.next();
String type = ResourceTypeToValue.lookup(record.typeCode);
Builder<Map<String, Object>> builder = ResourceRecordSet.builder()
.name(record.name)
.type(type)
.ttl(record.ttl);
builder.add(toMap(type, record.rdata));
while (hasNext()) {
Record next = peekingIterator.peek();
if (fqdnAndTypeEquals(next, record)) {
peekingIterator.next();
builder.add(toMap(type, next.rdata));
} else {
break;
}
}
return builder.build();
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
| 129 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSException.java | package denominator.ultradns;
import feign.FeignException;
class UltraDNSException extends FeignException {
/**
* System Error
*/
static final int SYSTEM_ERROR = 9999;
/**
* Zone does not exist in the system.
*/
static final int ZONE_NOT_FOUND = 1801;
/**
* Zone already exists in the system.
*/
static final int ZONE_ALREADY_EXISTS = 1802;
/**
* No resource record with GUID found in the system.
*/
static final int RESOURCE_RECORD_NOT_FOUND = 2103;
/**
* Resource record exists with the same name and type.
*/
static final int RESOURCE_RECORD_ALREADY_EXISTS = 2111;
// there are 51002 potential codes. These are the ones we are handling.
/**
* No Pool or Multiple pools of same type exists for the PoolName
*/
static final int DIRECTIONALPOOL_NOT_FOUND = 2142;
/**
* Invalid zone name
*/
static final int INVALID_ZONE_NAME = 2507;
/**
* Directional Pool Record does not exist in the system
*/
static final int DIRECTIONALPOOL_RECORD_NOT_FOUND = 2705;
/**
* Pool does not exist in the system.
*/
static final int POOL_NOT_FOUND = 2911;
/**
* Pool already created for the given rrGUID.
*/
static final int POOL_ALREADY_EXISTS = 2912;
/**
* Group does not exist.
*/
static final int GROUP_NOT_FOUND = 4003;
/**
* Directional feature not Enabled or Directional migration is not done.
*/
static final int DIRECTIONAL_NOT_ENABLED = 4006;
/**
* Resource Record already exists.
*/
static final int POOL_RECORD_ALREADY_EXISTS = 4009;
private static final long serialVersionUID = 1L;
private final int code;
UltraDNSException(String message, int code) {
super(message);
this.code = code;
}
/**
* The error code. ex {@code 1801}
*/
public int code() {
return code;
}
}
| 130 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSZoneApi.java | package denominator.ultradns;
import java.util.Iterator;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Provider;
import denominator.model.Zone;
import denominator.ultradns.UltraDNS.Record;
import static denominator.common.Preconditions.checkState;
import static denominator.common.Util.singletonIterator;
public final class UltraDNSZoneApi implements denominator.ZoneApi {
private final UltraDNS api;
private final Provider<String> account;
@Inject
UltraDNSZoneApi(UltraDNS api, @Named("accountID") Provider<String> account) {
this.api = api;
this.account = account;
}
/**
* in UltraDNS, zones are scoped to an account.
*/
@Override
public Iterator<Zone> iterator() {
final Iterator<String> delegate = api.getZonesOfAccount(account.get()).iterator();
return new Iterator<Zone>() {
@Override
public boolean hasNext() {
return delegate.hasNext();
}
@Override
public Zone next() {
return fromSOA(delegate.next());
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
@Override
public Iterator<Zone> iterateByName(String name) {
Zone zone = null;
try {
zone = fromSOA(name);
} catch (UltraDNSException e) {
if (e.code() != UltraDNSException.ZONE_NOT_FOUND
&& e.code() != UltraDNSException.INVALID_ZONE_NAME) {
throw e;
}
}
return singletonIterator(zone);
}
@Override
public String put(Zone zone) {
try {
api.createPrimaryZone(account.get(), zone.name());
} catch (UltraDNSException e) {
if (e.code() != UltraDNSException.ZONE_ALREADY_EXISTS) {
throw e;
}
}
Record soa = api.getResourceRecordsOfDNameByType(zone.name(), zone.name(), 6).get(0);
soa.ttl = zone.ttl();
soa.rdata.set(1, zone.email());
soa.rdata.set(6, String.valueOf(zone.ttl()));
api.updateResourceRecord(soa, zone.name());
return zone.name();
}
@Override
public void delete(String name) {
try {
api.deleteZone(name);
} catch (UltraDNSException e) {
if (e.code() != UltraDNSException.ZONE_NOT_FOUND) {
throw e;
}
}
}
private Zone fromSOA(String name) {
List<Record> soas = api.getResourceRecordsOfDNameByType(name, name, 6);
checkState(!soas.isEmpty(), "SOA record for zone %s was not present", name);
Record soa = soas.get(0);
return Zone.create(name, name, soa.ttl, soa.rdata.get(1));
}
}
| 131 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSErrorDecoder.java | package denominator.ultradns;
import org.xml.sax.helpers.DefaultHandler;
import java.io.IOException;
import javax.inject.Inject;
import feign.FeignException;
import feign.Response;
import feign.RetryableException;
import feign.codec.Decoder;
import feign.codec.ErrorDecoder;
import feign.sax.SAXDecoder.ContentHandlerWithResult;
import static denominator.common.Util.slurp;
import static feign.Util.UTF_8;
import static java.lang.String.format;
class UltraDNSErrorDecoder implements ErrorDecoder {
private final Decoder decoder;
UltraDNSErrorDecoder(Decoder decoder) {
this.decoder = decoder;
}
static Response bufferResponse(Response response) throws IOException {
if (response.body() == null) {
return response;
}
String body = slurp(response.body().asReader());
return Response.create(response.status(), response.reason(), response.headers(), body, UTF_8);
}
@Override
public Exception decode(String methodKey, Response response) {
try {
// in case of error parsing, we can access the original contents.
response = bufferResponse(response);
UltraDNSError error = UltraDNSError.class.cast(decoder.decode(response, UltraDNSError.class));
if (error == null) {
return FeignException.errorStatus(methodKey, response);
}
String message = format("%s failed", methodKey);
if (error.code != -1) {
message = format("%s with error %s", message, error.code);
}
if (error.description != null) {
message = format("%s: %s", message, error.description);
}
if (error.code == UltraDNSException.SYSTEM_ERROR) {
return new RetryableException(message, null);
}
return new UltraDNSException(message, error.code);
} catch (IOException ignored) {
return FeignException.errorStatus(methodKey, response);
} catch (Exception propagate) {
return propagate;
}
}
static class UltraDNSError extends DefaultHandler
implements ContentHandlerWithResult<UltraDNSError> {
private StringBuilder currentText = new StringBuilder();
private int code = -1;
private String description;
@Inject
UltraDNSError() {
}
@Override
public UltraDNSError result() {
return (code == -1 && description == null) ? null : this;
}
@Override
public void endElement(String uri, String name, String qName) {
if (qName.endsWith("errorCode")) {
code = Integer.parseInt(currentText.toString().trim());
} else if (qName.endsWith("errorDescription") || qName.endsWith("faultstring")) {
description = currentText.toString().trim();
if ("".equals(description)) {
description = null;
}
}
currentText = new StringBuilder();
}
@Override
public void characters(char ch[], int start, int length) {
currentText.append(ch, start, length);
}
}
}
| 132 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSGeoSupport.java | package denominator.ultradns;
import java.util.Collection;
import java.util.Map;
import javax.inject.Named;
import dagger.Module;
import dagger.Provides;
@Module(injects = UltraDNSGeoResourceRecordSetApi.Factory.class, complete = false)
public class UltraDNSGeoSupport {
@Provides
@Named("geo")
Map<String, Collection<String>> regions(UltraDNS api) {
return api.getAvailableRegions();
}
}
| 133 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSContentHandlers.java | package denominator.ultradns;
import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.TreeMap;
import denominator.ultradns.UltraDNS.DirectionalGroup;
import denominator.ultradns.UltraDNS.DirectionalRecord;
import denominator.ultradns.UltraDNS.NameAndType;
import denominator.ultradns.UltraDNS.NetworkStatus;
import denominator.ultradns.UltraDNS.Record;
import feign.sax.SAXDecoder;
import feign.sax.SAXDecoder.ContentHandlerWithResult;
import static denominator.common.Util.split;
/**
* all decoders use {@code .endsWith} as a cheap way to strip out namespaces, such as {@code ns2:}.
*/
class UltraDNSContentHandlers {
static final SimpleDateFormat iso8601 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
static {
iso8601.setTimeZone(TimeZone.getTimeZone("GMT"));
}
private static final Comparator<Record> byNameTypeAndCreateDate = new Comparator<Record>() {
@Override
public int compare(Record left, Record right) {
int nameCompare = left.name.compareTo(right.name);
if (nameCompare != 0) {
return nameCompare;
}
int typeCompare = new Integer(left.typeCode).compareTo(right.typeCode);
if (typeCompare != 0) {
return typeCompare;
}
// insertion order attempt
int createdCompare = left.created.compareTo(right.created);
if (createdCompare != 0) {
return createdCompare;
}
// UMP-5803 the order returned in getResourceRecordsOfZoneResponse
// is different than getResourceRecordsOfDNameByTypeResponse.
// We fallback to ordering by rdata to ensure consistent ordering.
return left.rdata.toString().compareTo(right.rdata.toString());
}
};
private static final Comparator<DirectionalRecord>
byTypeAndGeoGroup =
new Comparator<DirectionalRecord>() {
@Override
public int compare(DirectionalRecord left, DirectionalRecord right) {
int typeCompare = left.type.compareTo(right.type);
if (typeCompare != 0) {
return typeCompare;
}
return left.geoGroupName.compareTo(right.geoGroupName);
}
};
static Long tryParseDate(String dateString) {
synchronized (iso8601) {
try {
return iso8601.parse(dateString).getTime();
} catch (ParseException ignored) {
// only used for sorting, so don't break terribly
return null;
}
}
}
// text of <DirPoolID> <RRPoolID> <DirectionalPoolRecordID> or attribute accountID
static class IDHandler extends DefaultHandler implements ContentHandlerWithResult<String> {
private StringBuilder currentText = new StringBuilder();
private String id;
@Override
public String result() {
return id;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attrs) {
if (attrs.getValue("accountID") != null) {
id = attrs.getValue("accountID");
} else if (attrs.getValue("accountId") != null) {
id = attrs.getValue("accountId");
}
}
@Override
public void endElement(String uri, String name, String qName) {
if ("DirPoolID".equals(qName) || "RRPoolID".equals(qName) || "DirectionalPoolRecordID"
.equals(qName)) {
this.id = currentText.toString().trim().toUpperCase();
}
currentText = new StringBuilder();
}
@Override
public void characters(char ch[], int start, int length) {
currentText.append(ch, start, length);
}
}
static class NetworkStatusHandler extends DefaultHandler implements
SAXDecoder.ContentHandlerWithResult<NetworkStatus> {
private StringBuilder currentText = new StringBuilder();
private NetworkStatus status;
@Override
public NetworkStatus result() {
return status;
}
@Override
public void endElement(String uri, String name, String qName) {
if (qName.equals("NeustarNetworkStatus")) {
this.status = NetworkStatus.valueOf(currentText.toString().trim().toUpperCase());
}
currentText = new StringBuilder();
}
@Override
public void characters(char ch[], int start, int length) {
currentText.append(ch, start, length);
}
}
static class ZoneNamesHandler extends DefaultHandler
implements ContentHandlerWithResult<List<String>> {
private final List<String> zones = new ArrayList<String>();
@Override
public List<String> result() {
return zones;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attrs) {
if (attrs.getValue("zoneName") != null) {
zones.add(attrs.getValue("zoneName"));
}
}
}
static class RecordListHandler extends DefaultHandler
implements ContentHandlerWithResult<List<Record>> {
private final List<Record> rrs = new ArrayList<Record>();
private Record rr = new Record();
@Override
public List<Record> result() {
Collections.sort(rrs, byNameTypeAndCreateDate);
return rrs;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attrs) {
if (qName.endsWith("ResourceRecord")) {
rr.id = attrs.getValue("Guid");
rr.created = tryParseDate(attrs.getValue("Created"));
rr.typeCode = Integer.parseInt(attrs.getValue("Type"));
rr.name = attrs.getValue("DName");
rr.ttl = Integer.parseInt(attrs.getValue("TTL"));
} else if (qName.endsWith("InfoValues")) {
for (int i = 0; i < attrs.getLength(); i++) {
rr.rdata.add(attrs.getValue(i));
}
}
}
@Override
public void endElement(String uri, String name, String qName) {
if (qName.endsWith("ResourceRecord")) {
rrs.add(rr);
rr = new Record();
}
}
}
static class RRPoolListHandler extends DefaultHandler
implements ContentHandlerWithResult<Map<NameAndType, String>> {
private final Map<NameAndType, String> pools = new LinkedHashMap<NameAndType, String>();
private NameAndType nameAndType = new NameAndType();
private String id;
@Override
public Map<NameAndType, String> result() {
return pools;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attrs) {
if (qName.endsWith("PoolData")) {
nameAndType.name = attrs.getValue("PoolDName");
nameAndType.type = attrs.getValue("PoolRecordType");
id = attrs.getValue("PoolId");
}
}
@Override
public void endElement(String uri, String name, String qName) {
if (qName.endsWith("LBPoolData")) {
pools.put(nameAndType, id);
nameAndType = new NameAndType();
id = null;
}
}
}
static class DirectionalPoolListHandler extends DefaultHandler implements
ContentHandlerWithResult<Map<String, String>> {
private final Map<String, String> pools = new LinkedHashMap<String, String>();
private String name;
private String id;
@Override
public Map<String, String> result() {
return pools;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attrs) {
if (qName.endsWith("PoolData") && "GEOLOCATION".equals(attrs.getValue("DirPoolType"))) {
name = attrs.getValue("Pooldname");
id = attrs.getValue("dirpoolid");
}
}
@Override
public void endElement(String uri, String ignored, String qName) {
if (qName.endsWith("DirectionalPoolData") && name != null) {
pools.put(name, id);
name = null;
id = null;
}
}
}
static class RegionTableHandler extends DefaultHandler implements
ContentHandlerWithResult<Map<String, Collection<String>>> {
private final Map<String, Collection<String>>
regions =
new TreeMap<String, Collection<String>>();
@Override
public Map<String, Collection<String>> result() {
return regions;
}
@Override
public void startElement(String url, String name, String qName, Attributes attrs) {
if (qName.endsWith("Region")) {
List<String> territories = split(';', attrs.getValue("TerritoryName"));
Collections.sort(territories);
regions.put(attrs.getValue("RegionName"), territories);
}
}
}
static class DirectionalGroupHandler extends DefaultHandler
implements ContentHandlerWithResult<DirectionalGroup> {
private final DirectionalGroup group = new DirectionalGroup();
@Override
public DirectionalGroup result() {
return group;
}
@Override
public void startElement(String url, String name, String qName, Attributes attrs) {
if (qName.endsWith("DirectionalDNSGroupDetail")) {
group.name = attrs.getValue("GroupName");
} else if (qName.endsWith("RegionForNewGroups")) {
String regionName = attrs.getValue("RegionName");
List<String> territories = split(';', attrs.getValue("TerritoryName"));
Collections.sort(territories);
group.regionToTerritories.put(regionName, territories);
}
}
}
static class DirectionalRecordListHandler extends DefaultHandler implements
ContentHandlerWithResult<List<DirectionalRecord>> {
private final List<DirectionalRecord> rrs = new ArrayList<DirectionalRecord>();
private DirectionalRecord rr = new DirectionalRecord();
private String currentName;
@Override
public List<DirectionalRecord> result() {
Collections.sort(rrs, byTypeAndGeoGroup);
return rrs;
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attrs) {
if (qName.endsWith("DirectionalDNSRecordDetailList")) {
currentName = attrs.getValue("DName");
} else if (qName.endsWith("DirectionalDNSRecordDetail")) {
rr.id = attrs.getValue("DirPoolRecordId");
rr.geoGroupId = attrs.getValue("GeolocationGroupId");
rr.geoGroupName = attrs.getValue("GeolocationGroupName");
} else if (qName.endsWith("DirectionalDNSRecord")) {
rr.type = attrs.getValue("recordType");
rr.noResponseRecord = Boolean.parseBoolean(attrs.getValue("noResponseRecord"));
rr.ttl = Integer.parseInt(attrs.getValue("TTL"));
} else if (qName.endsWith("InfoValues")) {
for (int i = 0; i < attrs.getLength(); i++) {
rr.rdata.add(attrs.getValue(i));
}
}
}
@Override
public void endElement(String uri, String name, String qName) {
if (qName.endsWith("DirectionalDNSRecordDetail")) {
rr.name = currentName;
// ensure this is a geo record, not a source ip one.
if (rr.geoGroupName != null && rr.geoGroupId != null && rr.type != null) {
rrs.add(rr);
}
rr = new DirectionalRecord();
}
}
}
}
| 134 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSResourceRecordSetApi.java | package denominator.ultradns;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import denominator.ResourceRecordSetApi;
import denominator.model.ResourceRecordSet;
import denominator.ultradns.UltraDNS.Record;
import static denominator.ResourceTypeToValue.lookup;
import static denominator.common.Preconditions.checkArgument;
import static denominator.common.Preconditions.checkNotNull;
import static denominator.common.Util.nextOrNull;
import static denominator.common.Util.toMap;
final class UltraDNSResourceRecordSetApi implements denominator.ResourceRecordSetApi {
private static final int DEFAULT_TTL = 300;
private final UltraDNS api;
private final String zoneName;
private final UltraDNSRoundRobinPoolApi roundRobinPoolApi;
UltraDNSResourceRecordSetApi(UltraDNS api, String zoneName,
UltraDNSRoundRobinPoolApi roundRobinPoolApi) {
this.api = api;
this.zoneName = zoneName;
this.roundRobinPoolApi = roundRobinPoolApi;
}
@Override
public Iterator<ResourceRecordSet<?>> iterator() {
// this will list all basic or RR pool records.
Iterator<Record> orderedRecords = api.getResourceRecordsOfZone(zoneName).iterator();
return new GroupByRecordNameAndTypeIterator(orderedRecords);
}
@Override
public Iterator<ResourceRecordSet<?>> iterateByName(String name) {
checkNotNull(name, "name");
Iterator<Record> ordered = api.getResourceRecordsOfDNameByType(zoneName, name, 0).iterator();
return new GroupByRecordNameAndTypeIterator(ordered);
}
@Override
public ResourceRecordSet<?> getByNameAndType(String name, String type) {
checkNotNull(name, "name");
checkNotNull(type, "type");
Iterator<Record> orderedRecords = recordsByNameAndType(name, type).iterator();
return nextOrNull(new GroupByRecordNameAndTypeIterator(orderedRecords));
}
private List<Record> recordsByNameAndType(String name, String type) {
checkNotNull(name, "name");
checkNotNull(type, "type");
int typeValue = checkNotNull(lookup(type), "typeValue for %s", type);
return api.getResourceRecordsOfDNameByType(zoneName, name, typeValue);
}
@Override
public void put(ResourceRecordSet<?> rrset) {
checkNotNull(rrset, "rrset was null");
checkArgument(!rrset.records().isEmpty(), "rrset was empty %s", rrset);
int ttlToApply = rrset.ttl() != null ? rrset.ttl() : DEFAULT_TTL;
List<Record> toUpdate = recordsByNameAndType(rrset.name(), rrset.type());
List<Map<String, Object>> toCreate = new ArrayList<Map<String, Object>>(rrset.records());
for (Iterator<Record> shouldUpdate = toUpdate.iterator(); shouldUpdate.hasNext();) {
Record record = shouldUpdate.next();
Map<String, Object> rdata = toMap(rrset.type(), record.rdata);
if (toCreate.contains(rdata)) {
toCreate.remove(rdata);
if (ttlToApply == record.ttl) {
shouldUpdate.remove();
}
} else {
shouldUpdate.remove();
remove(rrset.name(), rrset.type(), record.id);
}
}
if (!toUpdate.isEmpty()) {
update(rrset.name(), rrset.type(), ttlToApply, toUpdate);
}
if (!toCreate.isEmpty()) {
create(rrset.name(), rrset.type(), ttlToApply, toCreate);
}
}
private void update(String name, String type, int ttlToApply, List<Record> toUpdate) {
if (roundRobinPoolApi.isPoolType(type)) {
String lbPoolId = roundRobinPoolApi.getPoolByNameAndType(name, type);
for (Record record : toUpdate) {
api.updateRecordOfRRPool(record.id, lbPoolId, record.rdata.get(0), ttlToApply);
}
} else {
for (Record record : toUpdate) {
record.ttl = ttlToApply;
api.updateResourceRecord(record, zoneName);
}
}
}
private void create(String name, String type, int ttl, List<Map<String, Object>> rdatas) {
if (roundRobinPoolApi.isPoolType(type)) {
roundRobinPoolApi.add(name, type, ttl, rdatas);
} else {
Record record = new Record();
record.name = name;
record.typeCode = lookup(type);
record.ttl = ttl;
for (Map<String, Object> rdata : rdatas) {
for (Object rdatum : rdata.values()) {
record.rdata.add(rdatum.toString());
}
api.createResourceRecord(record, zoneName);
}
}
}
@Override
public void deleteByNameAndType(String name, String type) {
for (Record record : recordsByNameAndType(name, type)) {
remove(name, type, record.id);
}
}
private void remove(String name, String type, String id) {
try {
api.deleteResourceRecord(id);
} catch (UltraDNSException e) {
// lost race
if (e.code() != UltraDNSException.RESOURCE_RECORD_NOT_FOUND) {
throw e;
}
}
if (roundRobinPoolApi.isPoolType(type)) {
roundRobinPoolApi.deletePool(name, type);
}
}
static final class Factory implements denominator.ResourceRecordSetApi.Factory {
private final UltraDNS api;
@Inject
Factory(UltraDNS api) {
this.api = api;
}
@Override
public ResourceRecordSetApi create(String name) {
return new UltraDNSResourceRecordSetApi(api, name, new UltraDNSRoundRobinPoolApi(api, name));
}
}
}
| 135 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSTarget.java | package denominator.ultradns;
import java.net.URI;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import denominator.Credentials;
import denominator.Provider;
import feign.Request;
import feign.RequestTemplate;
import feign.Target;
import static denominator.common.Preconditions.checkNotNull;
import static feign.Util.UTF_8;
import static java.lang.String.format;
class UltraDNSTarget implements Target<UltraDNS> {
static final String SOAP_TEMPLATE = "<?xml version=\"1.0\"?>\n"
+ "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:v01=\"http://webservice.api.ultra.neustar.com/v01/\">\n"
+ " <soapenv:Header>\n"
+ " <wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\" soapenv:mustUnderstand=\"1\">\n"
+ " <wsse:UsernameToken>\n"
+ " <wsse:Username>%s</wsse:Username>\n"
+ " <wsse:Password Type=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText\">%s</wsse:Password>\n"
+ " </wsse:UsernameToken>\n"
+ " </wsse:Security>\n"
+ " </soapenv:Header>\n"
+ " <soapenv:Body>\n"
+ " %s\n"
+ " </soapenv:Body>\n"
+ "</soapenv:Envelope>";
private final Provider provider;
private final javax.inject.Provider<Credentials> credentials;
@Inject
UltraDNSTarget(Provider provider, javax.inject.Provider<Credentials> credentials) {
this.provider = provider;
this.credentials = credentials;
}
@Override
public Class<UltraDNS> type() {
return UltraDNS.class;
}
@Override
public String name() {
return provider.name();
}
@Override
public String url() {
return provider.url();
}
@Override
public Request apply(RequestTemplate in) {
String username;
String password;
Credentials creds = credentials.get();
if (creds instanceof List) {
@SuppressWarnings("unchecked")
List<Object> listCreds = (List<Object>) creds;
username = listCreds.get(0).toString();
password = listCreds.get(1).toString();
} else if (creds instanceof Map) {
@SuppressWarnings("unchecked")
Map<String, Object> mapCreds = (Map<String, Object>) creds;
username = checkNotNull(mapCreds.get("username"), "username").toString();
password = checkNotNull(mapCreds.get("password"), "password").toString();
} else {
throw new IllegalArgumentException("Unsupported credential type: "+ creds);
}
in.insert(0, url());
in.body(format(SOAP_TEMPLATE, username, password, new String(in.body(), UTF_8)));
in.header("Host", URI.create(in.url()).getHost());
return in.request();
}
}
| 136 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNS.java | package denominator.ultradns;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import feign.Body;
import feign.Headers;
import feign.Param;
import feign.RequestLine;
@Headers("Content-Type: application/xml")
interface UltraDNS {
@RequestLine("POST")
@Body("<v01:getNeustarNetworkStatus/>")
NetworkStatus getNeustarNetworkStatus();
@RequestLine("POST")
@Body("<v01:getAccountsListOfUser/>")
String getAccountsListOfUser();
@RequestLine("POST")
@Body("<v01:getZonesOfAccount><accountId>{accountId}</accountId><zoneType>all</zoneType></v01:getZonesOfAccount>")
List<String> getZonesOfAccount(@Param("accountId") String accountId);
@RequestLine("POST")
@Body("<v01:createPrimaryZone><transactionID/><accountId>{accountId}</accountId><zoneName>{zoneName}</zoneName><forceImport>false</forceImport></v01:createPrimaryZone>")
void createPrimaryZone(@Param("accountId") String accountId, @Param("zoneName") String zoneName);
/**
* @throws UltraDNSException with code {@link UltraDNSException#ZONE_NOT_FOUND}.
*/
@RequestLine("POST")
@Body("<v01:deleteZone><transactionID /><zoneName>{zoneName}</zoneName></v01:deleteZone>")
void deleteZone(@Param("zoneName") String zoneName);
@RequestLine("POST")
@Body("<v01:getResourceRecordsOfZone><zoneName>{zoneName}</zoneName><rrType>0</rrType></v01:getResourceRecordsOfZone>")
List<Record> getResourceRecordsOfZone(@Param("zoneName") String zoneName);
@RequestLine("POST")
@Body("<v01:getResourceRecordsOfDNameByType><zoneName>{zoneName}</zoneName><hostName>{hostName}</hostName><rrType>{rrType}</rrType></v01:getResourceRecordsOfDNameByType>")
List<Record> getResourceRecordsOfDNameByType(@Param("zoneName") String zoneName,
@Param("hostName") String hostName,
@Param("rrType") int rrType);
@RequestLine("POST")
void createResourceRecord(@Param("resourceRecord") Record create,
@Param("zoneName") String zoneName);
@RequestLine("POST")
void updateResourceRecord(@Param("resourceRecord") Record update,
@Param("zoneName") String zoneName);
/**
* @throws UltraDNSException with code {@link UltraDNSException#RESOURCE_RECORD_NOT_FOUND} .
*/
@RequestLine("POST")
@Body("<v01:deleteResourceRecord><transactionID /><guid>{guid}</guid></v01:deleteResourceRecord>")
void deleteResourceRecord(@Param("guid") String guid);
@RequestLine("POST")
@Body("<v01:getLoadBalancingPoolsByZone><zoneName>{zoneName}</zoneName><lbPoolType>RR</lbPoolType></v01:getLoadBalancingPoolsByZone>")
Map<NameAndType, String> getLoadBalancingPoolsByZone(@Param("zoneName") String zoneName);
@RequestLine("POST")
@Body("<v01:getRRPoolRecords><lbPoolId>{poolId}</lbPoolId></v01:getRRPoolRecords>")
List<Record> getRRPoolRecords(@Param("poolId") String poolId);
@RequestLine("POST")
@Body("<v01:addRRLBPool><transactionID /><zoneName>{zoneName}</zoneName><hostName>{hostName}</hostName><description>{poolRecordType}</description><poolRecordType>{poolRecordType}</poolRecordType><rrGUID /></v01:addRRLBPool>")
String addRRLBPool(@Param("zoneName") String zoneName, @Param("hostName") String name,
@Param("poolRecordType") int typeCode);
@RequestLine("POST")
@Body("<v01:addRecordToRRPool><transactionID /><roundRobinRecord lbPoolID=\"{lbPoolID}\" info1Value=\"{address}\" ZoneName=\"{zoneName}\" Type=\"{type}\" TTL=\"{ttl}\"/></v01:addRecordToRRPool>")
void addRecordToRRPool(@Param("type") int type, @Param("ttl") int ttl,
@Param("address") String rdata,
@Param("lbPoolID") String lbPoolID, @Param("zoneName") String zoneName);
@RequestLine("POST")
@Body("<v01:updateRecordOfRRPool><transactionID /><resourceRecord rrGuid=\"{rrGuid}\" lbPoolID=\"{lbPoolID}\" info1Value=\"{info1Value}\" TTL=\"{ttl}\"/></v01:updateRecordOfRRPool>")
void updateRecordOfRRPool(@Param("rrGuid") String rrGuid, @Param("lbPoolID") String lbPoolID,
@Param("info1Value") String info1Value, @Param("ttl") int ttl);
/**
* @throws UltraDNSException with code {@link UltraDNSException#POOL_NOT_FOUND} and {@link
* UltraDNSException#RESOURCE_RECORD_NOT_FOUND}.
*/
@RequestLine("POST")
@Body("<v01:deleteLBPool><transactionID /><lbPoolID>{lbPoolID}</lbPoolID><DeleteAll>Yes</DeleteAll><retainRecordId /></v01:deleteLBPool>")
void deleteLBPool(@Param("lbPoolID") String id);
@RequestLine("POST")
@Body("<v01:getAvailableRegions />")
Map<String, Collection<String>> getAvailableRegions();
@RequestLine("POST")
@Body("<v01:getDirectionalDNSGroupDetails><GroupId>{GroupId}</GroupId></v01:getDirectionalDNSGroupDetails>")
DirectionalGroup getDirectionalDNSGroupDetails(@Param("GroupId") String groupId);
@RequestLine("POST")
@Body("<v01:getDirectionalDNSRecordsForGroup><groupName>{groupName}</groupName><hostName>{hostName}</hostName><zoneName>{zoneName}</zoneName><poolRecordType>{poolRecordType}</poolRecordType></v01:getDirectionalDNSRecordsForGroup>")
List<DirectionalRecord> getDirectionalDNSRecordsForGroup(@Param("zoneName") String zoneName,
@Param("groupName") String groupName,
@Param("hostName") String name,
@Param("poolRecordType") int type);
/**
* @throws UltraDNSException with code {@link UltraDNSException#POOL_RECORD_ALREADY_EXISTS}.
*/
@RequestLine("POST")
String addDirectionalPoolRecord(@Param("record") DirectionalRecord toCreate,
@Param("group") DirectionalGroup group,
@Param("poolId") String poolId);
/**
* @throws UltraDNSException with code {@link UltraDNSException#RESOURCE_RECORD_ALREADY_EXISTS}.
*/
@RequestLine("POST")
void updateDirectionalPoolRecord(@Param("record") DirectionalRecord update,
@Param("group") DirectionalGroup group);
@RequestLine("POST")
@Body("<v01:getDirectionalPoolsOfZone><zoneName>{zoneName}</zoneName></v01:getDirectionalPoolsOfZone>")
Map<String, String> getDirectionalPoolsOfZone(@Param("zoneName") String zoneName);
@RequestLine("POST")
@Body("<v01:getDirectionalDNSRecordsForHost><zoneName>{zoneName}</zoneName><hostName>{hostName}</hostName><poolRecordType>{poolRecordType}</poolRecordType></v01:getDirectionalDNSRecordsForHost>")
List<DirectionalRecord> getDirectionalDNSRecordsForHost(@Param("zoneName") String zoneName,
@Param("hostName") String name,
@Param("poolRecordType") int rrType);
@RequestLine("POST")
@Body("<v01:addDirectionalPool><transactionID /><AddDirectionalPoolData dirPoolType=\"GEOLOCATION\" poolRecordType=\"{poolRecordType}\" zoneName=\"{zoneName}\" hostName=\"{hostName}\" description=\"{poolRecordType}\"/></v01:addDirectionalPool>")
String addDirectionalPool(@Param("zoneName") String zoneName, @Param("hostName") String name,
@Param("poolRecordType") String type);
@RequestLine("POST")
@Body("<v01:deleteDirectionalPoolRecord><transactionID /><dirPoolRecordId>{dirPoolRecordId}</dirPoolRecordId></v01:deleteDirectionalPoolRecord>")
void deleteDirectionalPoolRecord(@Param("dirPoolRecordId") String id);
@RequestLine("POST")
@Body("<v01:deleteDirectionalPool><transactionID /><dirPoolID>{dirPoolID}</dirPoolID><retainRecordID /></v01:deleteDirectionalPool>")
void deleteDirectionalPool(@Param("dirPoolID") String dirPoolID);
enum NetworkStatus {
GOOD, FAILED;
}
class Record {
String id;
Long created;
String name;
int typeCode;
int ttl;
List<String> rdata = new ArrayList<String>();
}
class NameAndType {
String name;
String type;
@Override
public int hashCode() {
return 37 * name.hashCode() + type.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || !(obj instanceof NameAndType)) {
return false;
}
NameAndType that = NameAndType.class.cast(obj);
return this.name.equals(that.name) && this.type.equals(that.type);
}
@Override
public String toString() {
return "NameAndType(" + name + "," + type + ")";
}
}
class DirectionalGroup {
String name;
Map<String, Collection<String>> regionToTerritories = new TreeMap<String, Collection<String>>();
}
class DirectionalRecord extends Record {
String geoGroupId;
String geoGroupName;
boolean noResponseRecord;
String type;
}
}
| 137 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/NetworkStatusReadable.java | package denominator.ultradns;
import javax.inject.Inject;
import denominator.CheckConnection;
import denominator.ultradns.UltraDNS.NetworkStatus;
class NetworkStatusReadable implements CheckConnection {
private final UltraDNS api;
@Inject
NetworkStatusReadable(UltraDNS api) {
this.api = api;
}
@Override
public boolean ok() {
try {
return NetworkStatus.GOOD == api.getNeustarNetworkStatus();
} catch (RuntimeException e) {
return false;
}
}
@Override
public String toString() {
return "NetworkStatusReadable";
}
}
| 138 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSFormEncoder.java | package denominator.ultradns;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import denominator.ultradns.UltraDNS.DirectionalGroup;
import denominator.ultradns.UltraDNS.DirectionalRecord;
import denominator.ultradns.UltraDNS.Record;
import feign.RequestTemplate;
import feign.codec.Encoder;
import static denominator.common.Util.join;
import static java.lang.String.format;
class UltraDNSFormEncoder implements Encoder {
private static final String
CREATE_RR_TEMPLATE =
"<v01:createResourceRecord><transactionID /><resourceRecord ZoneName=\"%s\" Type=\"%s\" DName=\"%s\" TTL=\"%s\">%s</resourceRecord></v01:createResourceRecord>";
private static final String
CREATE_DR_TEMPLATE =
"<v01:addDirectionalPoolRecord><transactionID />%s%s%s<forceOverlapTransfer>true</forceOverlapTransfer></AddDirectionalRecordData></v01:addDirectionalPoolRecord>";
private static final String
UPDATE_DR_TEMPLATE =
"<v01:updateDirectionalPoolRecord><transactionID /><UpdateDirectionalRecordData directionalPoolRecordId=\"%s\">%s%s<forceOverlapTransfer>true</forceOverlapTransfer></UpdateDirectionalRecordData></v01:updateDirectionalPoolRecord>";
private static final String
CREATE_DGROUP_TEMPLATE =
"<GeolocationGroupData><GroupData groupingType=\"DEFINE_NEW_GROUP\" />%s</GeolocationGroupData>";
static String encodeZoneAndResourceRecord(Map<String, ?> formParams) {
String zoneName = formParams.get("zoneName").toString();
Record record = Record.class.cast(formParams.get("resourceRecord"));
String xml = toXML(zoneName, record);
if (record.id != null) {
xml = update(record.id, xml);
}
return xml;
}
static String toXML(String zoneName, Record record) {
StringBuilder values = new StringBuilder("<InfoValues");
for (int i = 0; i < record.rdata.size(); i++) {
values.append(' ').append("Info").append(i + 1).append("Value=").append('"')
.append(record.rdata.get(i))
.append('"');
}
values.append(" />");
return format(CREATE_RR_TEMPLATE, zoneName, record.typeCode, record.name, record.ttl,
values.toString());
}
static String update(Object guid, String xml) {
return xml.replace("createResourceRecord", "updateResourceRecord").replace("<resourceRecord",
format(
"<resourceRecord Guid=\"%s\"",
guid));
}
static String encodeRecordAndDirectionalGroup(Map<String, ?> formParams) {
DirectionalRecord record = DirectionalRecord.class.cast(formParams.get("record"));
DirectionalGroup group = DirectionalGroup.class.cast(formParams.get("group"));
return toXML(formParams.get("poolId"), record, group);
}
static String toXML(Object poolId, DirectionalRecord record, DirectionalGroup group) {
if (poolId == null) {
return format(UPDATE_DR_TEMPLATE, record.id, updateRecord(record), geo(group));
}
String addRecordToPool = format("<AddDirectionalRecordData directionalPoolId=\"%s\">", poolId);
return format(CREATE_DR_TEMPLATE, addRecordToPool, createRecord(record),
format(CREATE_DGROUP_TEMPLATE, geo(group)));
}
private static String createRecord(DirectionalRecord record) {
StringBuilder recordConfig = new StringBuilder();
recordConfig.append("<DirectionalRecordConfiguration recordType=\"").append(record.type)
.append('"');
recordConfig.append(" TTL=\"").append(record.ttl).append("\" >");
recordConfig.append(values(record));
recordConfig.append("</DirectionalRecordConfiguration>");
return recordConfig.toString();
}
/**
* don't pass type or is no response when updating
*/
private static String updateRecord(DirectionalRecord record) {
return format("<DirectionalRecordConfiguration TTL=\"%s\" >%s</DirectionalRecordConfiguration>",
record.ttl,
values(record));
}
private static String values(DirectionalRecord record) {
StringBuilder values = new StringBuilder("<InfoValues");
for (int i = 0; i < record.rdata.size(); i++) {
values.append(' ').append("Info").append(i + 1).append("Value=").append('"')
.append(record.rdata.get(i))
.append('"');
}
values.append(" />");
return values.toString();
}
private static String geo(DirectionalGroup group) {
StringBuilder groupData = new StringBuilder();
groupData.append("<GeolocationGroupDetails groupName=\"").append(group.name).append("\">");
for (Entry<String, Collection<String>> region : group.regionToTerritories.entrySet()) {
groupData.append("<GeolocationGroupDefinitionData regionName=\"").append(region.getKey())
.append('"');
groupData.append(" territoryNames=\"").append(join(';', region.getValue().toArray()))
.append("\" />");
}
groupData.append("</GeolocationGroupDetails>");
return groupData.toString();
}
@Override
public void encode(Object object, Type bodyType, RequestTemplate template) {
Map<String, ?> formParams = (Map<String, ?>) object;
if (formParams.containsKey("zoneName")) {
template.body(encodeZoneAndResourceRecord(formParams));
} else {
template.body(encodeRecordAndDirectionalGroup(formParams));
}
}
}
| 139 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSRoundRobinPoolApi.java | package denominator.ultradns;
import java.util.List;
import java.util.Map;
import denominator.ultradns.UltraDNS.NameAndType;
import static denominator.ResourceTypeToValue.lookup;
import static denominator.common.Preconditions.checkNotNull;
import static denominator.common.Preconditions.checkState;
class UltraDNSRoundRobinPoolApi {
private final UltraDNS api;
private final String zoneName;
UltraDNSRoundRobinPoolApi(UltraDNS api, String zoneName) {
this.api = api;
this.zoneName = zoneName;
}
boolean isPoolType(String type) {
return type.equals("A") || type.equals("AAAA");
}
void add(String name, String type, int ttl, List<Map<String, Object>> rdatas) {
checkState(isPoolType(type), "%s not A or AAAA type", type);
String poolId = reuseOrCreatePoolForNameAndType(name, type);
for (Map<String, Object> rdata : rdatas) {
String address = rdata.get("address").toString();
int typeCode = lookup(type);
api.addRecordToRRPool(typeCode, ttl, address, poolId, zoneName);
}
}
private String reuseOrCreatePoolForNameAndType(String name, String type) {
try {
return api.addRRLBPool(zoneName, name, lookup(type));
} catch (UltraDNSException e) {
if (e.code() != UltraDNSException.POOL_ALREADY_EXISTS) {
throw e;
}
return getPoolByNameAndType(name, type);
}
}
String getPoolByNameAndType(String name, String type) {
NameAndType nameAndType = new NameAndType();
nameAndType.name = name;
nameAndType.type = type;
return api.getLoadBalancingPoolsByZone(zoneName).get(nameAndType);
}
void deletePool(String name, String type) {
NameAndType nameAndType = new NameAndType();
nameAndType.name = checkNotNull(name, "pool name was null");
nameAndType.type = checkNotNull(type, "pool record type was null");
String poolId = api.getLoadBalancingPoolsByZone(zoneName).get(nameAndType);
if (poolId != null) {
if (api.getRRPoolRecords(poolId).isEmpty()) {
try {
api.deleteLBPool(poolId);
} catch (UltraDNSException e) {
switch (e.code()) {
// lost race
case UltraDNSException.POOL_NOT_FOUND:
case UltraDNSException.RESOURCE_RECORD_NOT_FOUND:
return;
}
throw e;
}
}
}
}
}
| 140 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSFilters.java | package denominator.ultradns;
import java.io.Serializable;
import denominator.common.Filter;
import denominator.ultradns.UltraDNS.Record;
import static denominator.common.Preconditions.checkNotNull;
final class UltraDNSFilters {
private UltraDNSFilters() {
}
public static Filter<Record> resourceTypeEqualTo(int typeValue) {
return new ResourceTypeEqualToPredicate(typeValue);
}
public static Filter<Record> recordIdEqualTo(String id) {
return new RecordIdEqualToPredicate(id);
}
/**
* @see UltraDNSFilters#resourceTypeEqualTo(int)
*/
private static class ResourceTypeEqualToPredicate implements Filter<Record>, Serializable {
private static final long serialVersionUID = 0;
private final int typeValue;
private ResourceTypeEqualToPredicate(int typeValue) {
this.typeValue = checkNotNull(typeValue, "typeValue");
}
@Override
public boolean apply(Record in) {
return typeValue == in.typeCode;
}
@Override
public String toString() {
return "ResourceTypeEqualTo(" + typeValue + ")";
}
}
private static class RecordIdEqualToPredicate implements Filter<Record>, Serializable {
private static final long serialVersionUID = 0;
private final String id;
private RecordIdEqualToPredicate(String id) {
this.id = checkNotNull(id, "id");
}
@Override
public boolean apply(Record in) {
return id.equals(in.id);
}
@Override
public String toString() {
return "RecordIdEqualTo(" + id + ")";
}
}
}
| 141 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSGeoResourceRecordSetApi.java | package denominator.ultradns;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Named;
import dagger.Lazy;
import denominator.Provider;
import denominator.common.Filter;
import denominator.model.ResourceRecordSet;
import denominator.profile.GeoResourceRecordSetApi;
import denominator.ultradns.UltraDNS.DirectionalGroup;
import denominator.ultradns.UltraDNS.DirectionalRecord;
import static denominator.ResourceTypeToValue.lookup;
import static denominator.common.Preconditions.checkArgument;
import static denominator.common.Preconditions.checkNotNull;
import static denominator.common.Util.concat;
import static denominator.common.Util.filter;
import static denominator.common.Util.nextOrNull;
import static denominator.common.Util.toMap;
import static denominator.model.ResourceRecordSets.nameAndTypeEqualTo;
final class UltraDNSGeoResourceRecordSetApi implements GeoResourceRecordSetApi {
private static final Filter<ResourceRecordSet<?>> IS_GEO = new Filter<ResourceRecordSet<?>>() {
@Override
public boolean apply(ResourceRecordSet<?> in) {
return in != null && in.geo() != null;
}
};
private static final int DEFAULT_TTL = 300;
private final Collection<String> supportedTypes;
private final Lazy<Map<String, Collection<String>>> regions;
private final UltraDNS api;
private final GroupGeoRecordByNameTypeIterator.Factory iteratorFactory;
private final String zoneName;
private final Filter<DirectionalRecord> isCNAME = new Filter<DirectionalRecord>() {
@Override
public boolean apply(DirectionalRecord input) {
return "CNAME".equals(input.type);
}
};
UltraDNSGeoResourceRecordSetApi(Collection<String> supportedTypes,
Lazy<Map<String, Collection<String>>> regions,
UltraDNS api,
GroupGeoRecordByNameTypeIterator.Factory iteratorFactory,
String zoneName) {
this.supportedTypes = supportedTypes;
this.regions = regions;
this.api = api;
this.iteratorFactory = iteratorFactory;
this.zoneName = zoneName;
}
@Override
public Map<String, Collection<String>> supportedRegions() {
return regions.get();
}
@Override
public Iterator<ResourceRecordSet<?>> iterator() {
List<Iterable<ResourceRecordSet<?>>> eachPool = new ArrayList<Iterable<ResourceRecordSet<?>>>();
for (final String poolName : api.getDirectionalPoolsOfZone(zoneName).keySet()) {
eachPool.add(new Iterable<ResourceRecordSet<?>>() {
public Iterator<ResourceRecordSet<?>> iterator() {
return iteratorForDNameAndDirectionalType(poolName, 0);
}
});
}
return concat(eachPool);
}
@Override
public Iterator<ResourceRecordSet<?>> iterateByName(String name) {
return iteratorForDNameAndDirectionalType(checkNotNull(name, "description"), 0);
}
@Override
public Iterator<ResourceRecordSet<?>> iterateByNameAndType(String name, String type) {
checkNotNull(name, "description");
checkNotNull(type, "type");
Filter<ResourceRecordSet<?>> filter = nameAndTypeEqualTo(name, type);
if (!supportedTypes.contains(type)) {
return Collections.<ResourceRecordSet<?>>emptyList().iterator();
}
if ("CNAME".equals(type)) {
// retain original type (this will filter out A, AAAA)
return filter(
concat(iteratorForDNameAndDirectionalType(name, lookup("A")),
iteratorForDNameAndDirectionalType(name, lookup("AAAA"))), filter);
} else if ("A".equals(type) || "AAAA".equals(type)) {
int dirType = "AAAA".equals(type) ? lookup("AAAA") : lookup("A");
Iterator<ResourceRecordSet<?>> iterator = iteratorForDNameAndDirectionalType(name, dirType);
// retain original type (this will filter out CNAMEs)
return filter(iterator, filter);
} else {
return iteratorForDNameAndDirectionalType(name, dirType(type));
}
}
@Override
public ResourceRecordSet<?> getByNameTypeAndQualifier(String name, String type,
String qualifier) {
checkNotNull(name, "description");
checkNotNull(type, "type");
checkNotNull(qualifier, "qualifier");
if (!supportedTypes.contains(type)) {
return null;
}
Iterator<DirectionalRecord> records = recordsByNameTypeAndQualifier(name, type, qualifier);
return nextOrNull(iteratorFactory.create(records));
}
private Iterator<DirectionalRecord> recordsByNameTypeAndQualifier(String name, String type,
String qualifier) {
if ("CNAME".equals(type)) {
return filter(
concat(recordsForNameTypeAndQualifier(name, "A", qualifier),
recordsForNameTypeAndQualifier(name, "AAAA", qualifier)), isCNAME);
} else {
return recordsForNameTypeAndQualifier(name, type, qualifier);
}
}
private Iterator<DirectionalRecord> recordsForNameTypeAndQualifier(String name, String type,
String qualifier) {
try {
return api.getDirectionalDNSRecordsForGroup(zoneName, qualifier, name, dirType(type))
.iterator();
} catch (UltraDNSException e) {
switch (e.code()) {
case UltraDNSException.GROUP_NOT_FOUND:
case UltraDNSException.DIRECTIONALPOOL_NOT_FOUND:
return Collections.<DirectionalRecord>emptyList().iterator();
}
throw e;
}
}
@Override
public void put(ResourceRecordSet<?> rrset) {
checkNotNull(rrset, "rrset was null");
checkArgument(rrset.qualifier() != null, "no qualifier on: %s", rrset);
checkArgument(IS_GEO.apply(rrset), "%s failed on: %s", IS_GEO, rrset);
checkArgument(supportedTypes.contains(rrset.type()), "%s not a supported type for geo: %s",
rrset.type(),
supportedTypes);
int ttlToApply = rrset.ttl() != null ? rrset.ttl() : DEFAULT_TTL;
String group = rrset.qualifier();
Map<String, Collection<String>> regions = rrset.geo().regions();
DirectionalGroup directionalGroup = new DirectionalGroup();
directionalGroup.name = group;
directionalGroup.regionToTerritories = regions;
List<Map<String, Object>>
recordsLeftToCreate =
new ArrayList<Map<String, Object>>(rrset.records());
Iterator<DirectionalRecord>
iterator =
recordsByNameTypeAndQualifier(rrset.name(), rrset.type(), group);
while (iterator.hasNext()) {
DirectionalRecord record = iterator.next();
Map<String, Object> rdata = toMap(record.type, record.rdata);
if (recordsLeftToCreate.contains(rdata)) {
recordsLeftToCreate.remove(rdata);
boolean shouldUpdate = false;
if (ttlToApply != record.ttl) {
record.ttl = ttlToApply;
shouldUpdate = true;
} else {
directionalGroup = api.getDirectionalDNSGroupDetails(record.geoGroupId);
if (!regions.equals(directionalGroup.regionToTerritories)) {
directionalGroup.regionToTerritories = regions;
shouldUpdate = true;
}
}
if (shouldUpdate) {
try {
api.updateDirectionalPoolRecord(record, directionalGroup);
} catch (UltraDNSException e) {
// lost race
if (e.code() != UltraDNSException.RESOURCE_RECORD_ALREADY_EXISTS) {
throw e;
}
}
}
} else {
try {
api.deleteResourceRecord(record.id);
} catch (UltraDNSException e) {
// lost race
if (e.code() != UltraDNSException.RESOURCE_RECORD_NOT_FOUND) {
throw e;
}
}
}
}
if (!recordsLeftToCreate.isEmpty()) {
// shotgun create
String poolId;
try {
String type = rrset.type();
if ("CNAME".equals(type)) {
type = "A";
}
poolId = api.addDirectionalPool(zoneName, rrset.name(), type);
} catch (UltraDNSException e) {
// lost race
if (e.code() == UltraDNSException.POOL_ALREADY_EXISTS) {
poolId = api.getDirectionalPoolsOfZone(zoneName).get(rrset.name());
} else {
throw e;
}
}
DirectionalRecord record = new DirectionalRecord();
record.type = rrset.type();
record.ttl = ttlToApply;
for (Map<String, Object> rdata : recordsLeftToCreate) {
for (Object rdatum : rdata.values()) {
record.rdata.add(rdatum.toString());
}
try {
api.addDirectionalPoolRecord(record, directionalGroup, poolId);
} catch (UltraDNSException e) {
// lost race
if (e.code() != UltraDNSException.POOL_RECORD_ALREADY_EXISTS) {
throw e;
}
}
}
}
}
private int dirType(String type) {
if ("A".equals(type) || "CNAME".equals(type)) {
return lookup("A");
} else if ("AAAA".equals(type)) {
return lookup("AAAA");
} else {
return lookup(type);
}
}
@Override
public void deleteByNameTypeAndQualifier(String name, String type, String qualifier) {
Iterator<DirectionalRecord> record = recordsByNameTypeAndQualifier(name, type, qualifier);
while (record.hasNext()) {
try {
api.deleteDirectionalPoolRecord(record.next().id);
} catch (UltraDNSException e) {
// lost race
if (e.code() != UltraDNSException.DIRECTIONALPOOL_RECORD_NOT_FOUND) {
throw e;
}
}
}
}
private Iterator<ResourceRecordSet<?>> iteratorForDNameAndDirectionalType(String name,
int dirType) {
List<DirectionalRecord> list;
try {
list = api.getDirectionalDNSRecordsForHost(zoneName, name, dirType);
} catch (UltraDNSException e) {
if (e.code() == UltraDNSException.DIRECTIONALPOOL_NOT_FOUND) {
list = Collections.emptyList();
} else {
throw e;
}
}
return iteratorFactory.create(list.iterator());
}
static final class Factory implements GeoResourceRecordSetApi.Factory {
private final Collection<String> supportedTypes;
private final Lazy<Map<String, Collection<String>>> regions;
private final UltraDNS api;
private final GroupGeoRecordByNameTypeIterator.Factory iteratorFactory;
@Inject
Factory(Provider provider, @Named("geo") Lazy<Map<String, Collection<String>>> regions,
UltraDNS api,
GroupGeoRecordByNameTypeIterator.Factory iteratorFactory) {
this.supportedTypes = provider.profileToRecordTypes().get("geo");
this.regions = regions;
this.api = api;
this.iteratorFactory = iteratorFactory;
}
@Override
public GeoResourceRecordSetApi create(String name) {
checkNotNull(name, "name was null");
// Eager fetch of regions to determine if directional records are supported or not.
try {
regions.get();
} catch (UltraDNSException e) {
if (e.code() == UltraDNSException.DIRECTIONAL_NOT_ENABLED) {
return null;
}
throw e;
}
return new UltraDNSGeoResourceRecordSetApi(supportedTypes, regions, api, iteratorFactory,
name);
}
}
}
| 142 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/InvalidatableAccountIdSupplier.java | package denominator.ultradns;
import javax.inject.Inject;
import javax.inject.Provider;
import javax.inject.Singleton;
import denominator.Credentials;
/**
* gets the last account id, expiring if the url or credentials changed
*/
// similar to guava MemoizingSupplier
@Singleton
class InvalidatableAccountIdSupplier {
private final denominator.Provider provider;
private final UltraDNS api;
private final Provider<Credentials> credentials;
transient volatile String lastUrl;
transient volatile int lastCredentialsHashCode;
transient volatile boolean initialized;
transient String value; // "value" does not need to be volatile; visibility piggy-backs on above
@Inject
InvalidatableAccountIdSupplier(denominator.Provider provider, UltraDNS api,
javax.inject.Provider<Credentials> credentials) {
this.provider = provider;
this.api = api;
this.credentials = credentials;
this.lastUrl = provider.url(); // for toString
}
public void invalidate() {
initialized = false;
}
public String get() {
String currentUrl = provider.url();
Credentials currentCreds = credentials.get();
if (needsRefresh(currentUrl, currentCreds)) {
synchronized (this) {
if (needsRefresh(currentUrl, currentCreds)) {
lastCredentialsHashCode = currentCreds.hashCode();
lastUrl = currentUrl;
String accountId = api.getAccountsListOfUser();
value = accountId;
initialized = true;
return accountId;
}
}
}
return value;
}
private boolean needsRefresh(String currentUrl, Credentials currentCreds) {
return !initialized || currentCreds.hashCode() != lastCredentialsHashCode || !currentUrl
.equals(lastUrl);
}
@Override
public String toString() {
return "InvalidatableAccountIdSupplier(" + lastUrl + ")";
}
}
| 143 |
0 | Create_ds/denominator/ultradns/src/main/java/denominator | Create_ds/denominator/ultradns/src/main/java/denominator/ultradns/UltraDNSProvider.java | package denominator.ultradns;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import javax.inject.Named;
import javax.inject.Singleton;
import dagger.Provides;
import denominator.BasicProvider;
import denominator.CheckConnection;
import denominator.DNSApiManager;
import denominator.QualifiedResourceRecordSetApi;
import denominator.ResourceRecordSetApi;
import denominator.ZoneApi;
import denominator.config.ConcatBasicAndQualifiedResourceRecordSets;
import denominator.config.NothingToClose;
import denominator.config.WeightedUnsupported;
import denominator.profile.GeoResourceRecordSetApi;
import denominator.ultradns.UltraDNS.DirectionalGroup;
import denominator.ultradns.UltraDNS.DirectionalRecord;
import denominator.ultradns.UltraDNSContentHandlers.DirectionalGroupHandler;
import denominator.ultradns.UltraDNSContentHandlers.DirectionalPoolListHandler;
import denominator.ultradns.UltraDNSContentHandlers.DirectionalRecordListHandler;
import denominator.ultradns.UltraDNSContentHandlers.IDHandler;
import denominator.ultradns.UltraDNSContentHandlers.NetworkStatusHandler;
import denominator.ultradns.UltraDNSContentHandlers.RRPoolListHandler;
import denominator.ultradns.UltraDNSContentHandlers.RecordListHandler;
import denominator.ultradns.UltraDNSContentHandlers.RegionTableHandler;
import denominator.ultradns.UltraDNSContentHandlers.ZoneNamesHandler;
import denominator.ultradns.UltraDNSErrorDecoder.UltraDNSError;
import feign.Feign;
import feign.Logger;
import feign.Request.Options;
import feign.codec.Decoder;
import feign.sax.SAXDecoder;
import static dagger.Provides.Type.SET;
public class UltraDNSProvider extends BasicProvider {
private final String url;
public UltraDNSProvider() {
this(null);
}
/**
* @param url if empty or null use default
*/
public UltraDNSProvider(String url) {
this.url =
url == null || url.isEmpty() ? "https://ultra-api.ultradns.com:8443/UltraDNS_WS/v01" : url;
}
@Override
public String url() {
return url;
}
/**
* harvested from the {@code RESOURCE RECORD TYPE CODES} section of the SOAP user guide, dated
* 2012-11-04.
*/
@Override
public Set<String> basicRecordTypes() {
Set<String> types = new LinkedHashSet<String>();
types.addAll(
Arrays.asList("A", "AAAA", "CNAME", "HINFO", "MX", "NAPTR", "NS", "PTR", "RP", "SOA", "SPF",
"SRV", "TXT"));
return types;
}
/**
* directional pools in ultra have types {@code IPV4} and {@code IPV6} which accept both CNAME and
* address types.
*/
@Override
public Map<String, Collection<String>> profileToRecordTypes() {
Map<String, Collection<String>>
profileToRecordTypes =
new LinkedHashMap<String, Collection<String>>();
profileToRecordTypes.put("geo",
Arrays
.asList("A", "AAAA", "CNAME", "HINFO", "MX", "NAPTR", "PTR", "RP",
"SRV", "TXT"));
profileToRecordTypes.put("roundRobin",
Arrays.asList("A", "AAAA", "HINFO", "MX", "NAPTR", "NS", "PTR", "RP",
"SPF", "SRV", "TXT"));
return profileToRecordTypes;
}
@Override
public Map<String, Collection<String>> credentialTypeToParameterNames() {
Map<String, Collection<String>> options = new LinkedHashMap<String, Collection<String>>();
options.put("password", Arrays.asList("username", "password"));
return options;
}
@dagger.Module(injects = DNSApiManager.class, complete = false, includes = {NothingToClose.class,
UltraDNSGeoSupport.class,
WeightedUnsupported.class,
ConcatBasicAndQualifiedResourceRecordSets.class,
FeignModule.class})
public static final class Module {
@Provides
CheckConnection checkConnection(NetworkStatusReadable checkConnection) {
return checkConnection;
}
@Provides
@Singleton
GeoResourceRecordSetApi.Factory provideGeoResourceRecordSetApiFactory(
UltraDNSGeoResourceRecordSetApi.Factory in) {
return in;
}
@Provides
@Singleton
ZoneApi provideZoneApi(UltraDNSZoneApi api) {
return api;
}
@Provides
@Named("accountID")
String account(InvalidatableAccountIdSupplier accountId) {
return accountId.get();
}
@Provides
@Singleton
ResourceRecordSetApi.Factory provideResourceRecordSetApiFactory(
UltraDNSResourceRecordSetApi.Factory factory) {
return factory;
}
@Provides(type = SET)
QualifiedResourceRecordSetApi.Factory factoryToProfiles(GeoResourceRecordSetApi.Factory in) {
return in;
}
}
@dagger.Module(injects = UltraDNSResourceRecordSetApi.Factory.class,
complete = false // doesn't bind Provider used by UltraDNSTarget
)
public static final class FeignModule {
@Provides
@Singleton
UltraDNS ultraDNS(Feign feign, UltraDNSTarget target) {
return feign.newInstance(target);
}
@Provides
Logger logger() {
return new Logger.NoOpLogger();
}
@Provides
Logger.Level logLevel() {
return Logger.Level.NONE;
}
@Provides
@Singleton
Feign feign(Logger logger, Logger.Level logLevel) {
/**
* {@link UltraDNS#updateDirectionalPoolRecord(DirectionalRecord, DirectionalGroup)} and {@link
* UltraDNS#addDirectionalPoolRecord(DirectionalRecord, DirectionalGroup, String)} can take up
* to 10 minutes to complete.
*/
Options options = new Options(10 * 1000, 10 * 60 * 1000);
Decoder decoder = decoder();
return Feign.builder()
.logger(logger)
.logLevel(logLevel)
.options(options)
.encoder(new UltraDNSFormEncoder())
.decoder(decoder)
.errorDecoder(new UltraDNSErrorDecoder(decoder))
.build();
}
static Decoder decoder() {
return SAXDecoder.builder()
.registerContentHandler(NetworkStatusHandler.class)
.registerContentHandler(IDHandler.class)
.registerContentHandler(ZoneNamesHandler.class)
.registerContentHandler(RecordListHandler.class)
.registerContentHandler(DirectionalRecordListHandler.class)
.registerContentHandler(DirectionalPoolListHandler.class)
.registerContentHandler(RRPoolListHandler.class)
.registerContentHandler(RegionTableHandler.class)
.registerContentHandler(DirectionalGroupHandler.class)
.registerContentHandler(UltraDNSError.class)
.build();
}
}
}
| 144 |
0 | Create_ds/denominator/cli/src/test/java/denominator | Create_ds/denominator/cli/src/test/java/denominator/cli/DenominatorTest.java | package denominator.cli;
import denominator.AllProfileResourceRecordSetApi;
import denominator.Credentials.ListCredentials;
import denominator.Credentials.MapCredentials;
import denominator.DNSApiManager;
import denominator.ResourceRecordSetApi;
import denominator.cli.Denominator.ListProviders;
import denominator.cli.GeoResourceRecordSetCommands.GeoRegionList;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordAddRegions;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordSetApplyTTL;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordSetGet;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordSetList;
import denominator.cli.GeoResourceRecordSetCommands.GeoTypeList;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetAdd;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetApplyTTL;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetDelete;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetGet;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetList;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetRemove;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetReplace;
import denominator.cli.ZoneCommands.ZoneAdd;
import denominator.cli.ZoneCommands.ZoneDelete;
import denominator.cli.ZoneCommands.ZoneList;
import denominator.cli.ZoneCommands.ZoneUpdate;
import denominator.common.Util;
import denominator.mock.MockProvider;
import denominator.model.ResourceRecordSet;
import denominator.model.Zone;
import denominator.model.profile.Geo;
import denominator.model.rdata.AData;
import denominator.model.rdata.CNAMEData;
import denominator.route53.AliasTarget;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.contrib.java.lang.system.Assertion;
import org.junit.contrib.java.lang.system.ExpectedSystemExit;
import org.junit.contrib.java.lang.system.RestoreSystemProperties;
import org.junit.contrib.java.lang.system.SystemErrRule;
import org.junit.rules.ExpectedException;
import java.io.IOException;
import java.net.URL;
import java.security.PrivateKey;
import java.security.cert.X509Certificate;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import static denominator.assertj.ModelAssertions.assertThat;
import static denominator.model.ResourceRecordSets.a;
import static denominator.model.ResourceRecordSets.cert;
import static denominator.model.ResourceRecordSets.srv;
import static java.util.Arrays.asList;
import static org.junit.Assert.fail;
public class DenominatorTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Rule
public final RestoreSystemProperties restoreSystemProperties = new RestoreSystemProperties();
// Use this to make sure the message logged
@Rule
public final SystemErrRule systemErrRule = new SystemErrRule().enableLog();
// use this to test exit occurred on malformed
@Rule
public final ExpectedSystemExit exit = ExpectedSystemExit.none();
DNSApiManager mgr = denominator.Denominator.create(new MockProvider());
@Test // denominator providers
public void listsAllProvidersWithCredentials() {
assertThat(ListProviders.providerAndCredentialsTable())
.isEqualTo(Util.join('\n',
"provider url duplicateZones credentialType credentialArgs",
"clouddns https://identity.api.rackspacecloud.com/v2.0 false password username password",
"clouddns https://identity.api.rackspacecloud.com/v2.0 false apiKey username apiKey",
"designate http://localhost:5000/v2.0 false password tenantId username password",
"dynect https://api2.dynect.net/REST false password customer username password",
"mock mem:mock false ",
"route53 https://route53.amazonaws.com true accessKey accessKey secretKey",
"route53 https://route53.amazonaws.com true session accessKey secretKey sessionToken",
"ultradns https://ultra-api.ultradns.com:8443/UltraDNS_WS/v01 false password username password",
""));
}
@Test // denominator -p mock zone list
public void testZoneList() {
assertThat(new ZoneList().doRun(mgr)).containsExactly(
"denominator.io. denominator.io. nil@denominator.io. 86400"
);
}
@Test // denominator -p mock zone list -n denominator.com.
public void testZoneListByNameWhenEmpty() {
ZoneList zoneList = new ZoneList();
zoneList.name = "denominator.com.";
assertThat(zoneList.doRun(mgr)).isEmpty();
}
@Test // denominator -u mem:mock2 -p mock zone list
public void testUrlArg() {
ZoneList zoneList = new ZoneList() {
@Override
public Iterator<String> doRun(DNSApiManager mgr) {
assertThat(mgr.provider().url()).isEqualTo("mem:mock2");
return Collections.<String>emptyList().iterator();
}
};
zoneList.providerName = "mock";
zoneList.url = "mem:mock2";
zoneList.run();
}
@Test
public void testCredentialsFromYaml() {
String yaml = getTestYaml();
ZoneList zoneList = new ZoneList();
zoneList.providerConfigurationName = "blah1";
Map<String, String> credentials = (Map) zoneList.getConfigFromYaml(yaml).get("credentials");
assertThat(credentials)
.containsEntry("accessKey", "foo1")
.containsEntry("secretKey", "foo2");
}
private String getTestYaml() {
return "name: blah1\n" +
"provider: route53\n" +
"credentials:\n" +
" accessKey: foo1\n" +
" secretKey: foo2\n" +
"---\n" +
"name: blah2\n" +
"provider: mock\n" +
"url: mem:mock2\n" +
"credentials:\n" +
" accessKey: foo3\n" +
" secretKey: foo4\n" +
" sessionToken: foo5\n" +
"\n";
}
@Test
public void testFileContentsFromPath() throws IOException {
ZoneList zoneList = new ZoneList();
assertThat(zoneList.getFileContentsFromPath(getTestConfigPath()))
.isEqualTo(getTestYaml());
}
@Test
public void testOverrideFromEnv() {
ZoneList zoneList = new ZoneList();
Map<String, String> env = new LinkedHashMap<String, String>();
env.put("DENOMINATOR_PROVIDER", "route53");
env.put("DENOMINATOR_URL", "mem:mock2");
env.put("DENOMINATOR_ACCESS_KEY", "foo1");
env.put("DENOMINATOR_SECRET_KEY", "foo2");
zoneList.overrideFromEnv(env);
assertThat(zoneList.providerName).isEqualTo("route53");
assertThat(zoneList.url).isEqualTo("mem:mock2");
assertThat((Map<String, Object>) zoneList.credentials)
.isInstanceOf(MapCredentials.class)
.containsEntry("accessKey", "foo1")
.containsEntry("secretKey", "foo2");
}
@Test // denominator -C test-config.yml -n blah2 zone list
public void testConfigArgMock() {
ZoneList zoneList = new ZoneList() {
@Override
public Iterator<String> doRun(DNSApiManager mgr) {
assertThat(configPath).isEqualTo(getTestConfigPath());
Map<String, Object> contents = (Map) getConfigFromFile();
assertThat(contents)
.containsEntry("provider", "mock")
.containsEntry("url", "mem:mock2");
Map<String, String> credentials = (Map) contents.get("credentials");
assertThat(credentials)
.containsEntry("accessKey", "foo3")
.containsEntry("secretKey", "foo4")
.containsEntry("sessionToken", "foo5");
return Collections.<String>emptyList().iterator();
}
};
zoneList.providerConfigurationName = "blah2";
zoneList.configPath = getTestConfigPath();
zoneList.run();
}
@Test // denominator -C test-config.yml -n blah1 zone list
public void testConfigArgRoute53() {
ZoneList zoneList = new ZoneList() {
@Override
public Iterator<String> doRun(DNSApiManager mgr) {
assertThat(configPath).isEqualTo(getTestConfigPath());
assertThat(Map.class.cast(credentials))
.containsEntry("accessKey", "foo1")
.containsEntry("secretKey", "foo2");
return Collections.<String>emptyList().iterator();
}
};
zoneList.providerConfigurationName = "blah1";
zoneList.configPath = getTestConfigPath();
zoneList.run();
}
@Test
public void testParseCertAndPrivateKeyInCredentials() {
ZoneList zoneList = new ZoneList() {
@Override
public Iterator<String> doRun(DNSApiManager mgr) {
assertThat(configPath).isEqualTo(getTestConfigPath("test-config-cert.yml"));
Map mapCredentials = Map.class.cast(credentials);
assertThat(((X509Certificate) mapCredentials.get("x509Certificate")).getSubjectDN().getName())
.containsIgnoringCase("C=US,ST=California,O=NetflixOSS,OU=Denominator,CN=Denominator");
PrivateKey privateKey = (PrivateKey) mapCredentials.get("privateKey");
assertThat(privateKey.getAlgorithm()).isEqualToIgnoringCase("RSA");
assertThat(privateKey.getFormat()).isEqualToIgnoringCase("PKCS#8");
return Collections.<String>emptyList().iterator();
}
};
zoneList.providerConfigurationName = "blah";
zoneList.configPath = getTestConfigPath("test-config-cert.yml");
zoneList.run();
}
@Test
// denominator -p mock zone add -n denominator.io. -e nil@denominator.io
public void testZoneAdd() {
ZoneAdd command = new ZoneAdd();
command.name = "denominator.io.";
command.email = "nil@denominator.io";
assertThat(command.doRun(mgr)).containsExactly(
";; adding zone denominator.io. with ttl 86400 and email nil@denominator.io",
"denominator.io.",
";; ok");
assertThat(mgr.api().zones().iterateByName(command.name))
.contains(Zone.create(command.name, command.name, command.ttl, command.email));
}
@Test
// denominator -p mock zone add -n denominator.io. -t 3601 -e nil@denominator.io
public void testZoneAdd_ttl() {
ZoneAdd command = new ZoneAdd();
command.name = "denominator.io.";
command.ttl = 3601;
command.email = "nil@denominator.io";
assertThat(command.doRun(mgr)).containsExactly(
";; adding zone denominator.io. with ttl 3601 and email nil@denominator.io",
"denominator.io.",
";; ok");
assertThat(mgr.api().zones().iterateByName(command.name))
.contains(Zone.create(command.name, command.name, command.ttl, command.email));
}
@Test
// denominator -p mock zone update -i denominator.io. -e nil@denominator.io
public void testZoneUpdate_email() {
ZoneUpdate command = new ZoneUpdate();
command.id = "denominator.io.";
command.email = "nil@denominator.io";
Zone before = mgr.api().zones().iterateByName(command.id).next();
assertThat(command.doRun(mgr)).containsExactly(
";; updating zone denominator.io. with email nil@denominator.io",
";; ok");
assertThat(mgr.api().zones().iterateByName(before.name()))
.contains(Zone.create(before.id(), before.name(), before.ttl(), command.email));
}
@Test
// denominator -p mock zone update -i denominator.io. -t 3601
public void testZoneUpdate_ttl() {
ZoneUpdate command = new ZoneUpdate();
command.id = "denominator.io.";
command.ttl = 3601;
Zone before = mgr.api().zones().iterateByName(command.id).next();
assertThat(command.doRun(mgr)).containsExactly(
";; updating zone denominator.io. with ttl 3601",
";; ok");
assertThat(mgr.api().zones().iterateByName(before.name()))
.contains(Zone.create(before.id(), before.name(), command.ttl, before.email()));
}
@Test
// denominator -p mock zone update -i denominator.io. -t 3601 -e nil@denominator.io
public void testZoneUpdate_ttlAndEmail() {
ZoneUpdate command = new ZoneUpdate();
command.id = "denominator.io.";
command.ttl = 3601;
command.email = "nil@denominator.io";
Zone before = mgr.api().zones().iterateByName(command.id).next();
assertThat(command.doRun(mgr)).containsExactly(
";; updating zone denominator.io. with ttl 3601 and email nil@denominator.io",
";; ok");
assertThat(mgr.api().zones().iterateByName(before.name()))
.contains(Zone.create(before.id(), before.name(), command.ttl, command.email));
}
@Test
// denominator -p mock zone update -i denominator.io. -t 3601 -e nil@denominator.io
public void testZoneUpdate_noop() {
Zone before = mgr.api().zones().iterateByName("denominator.io.").next();
ZoneUpdate command = new ZoneUpdate();
command.id = before.id();
command.ttl = before.ttl();
command.email = before.email();
assertThat(command.doRun(mgr)).containsExactly(
";; ok");
assertThat(mgr.api().zones().iterateByName(before.name()))
.contains(before);
}
@Test
// denominator -p mock zone update -i denominator.com. -e nil@denominator.io
public void testZoneUpdate_doesntExist() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("zone denominator.com. not found");
ZoneUpdate command = new ZoneUpdate();
command.id = "denominator.com.";
command.email = "nil@denominator.io";
command.doRun(mgr);
}
@Test
// denominator -p mock zone delete -i denominator.io.
public void testZoneDelete() {
ZoneDelete command = new ZoneDelete();
command.id = "denominator.io.";
assertThat(command.doRun(mgr)).containsExactly(
";; deleting zone denominator.io.",
";; ok");
assertThat(mgr.api().zones()).isEmpty();
}
@Test // denominator -C test-config.yml -p route53 -c user pass -n blah1 zone list
public void testConfigArgWithCliOverride() {
ZoneList zoneList = new ZoneList() {
@Override
public Iterator<String> doRun(DNSApiManager mgr) {
assertThat(credentialArgs).containsExactly("user", "pass");
// CLI credential args should override config file args
assertThat(credentials).isInstanceOf(ListCredentials.class);
assertThat((ListCredentials) credentials).containsExactly("user", "pass");
return Collections.<String>emptyList().iterator();
}
};
zoneList.providerConfigurationName = "blah1";
zoneList.providerName = "route53";
zoneList.configPath = getTestConfigPath();
zoneList.credentialArgs = asList("user", "pass");
zoneList.run();
}
@Test
public void testParseCertAndPrivateKeyInCLICredentials() throws IOException {
ZoneList zoneList = new ZoneList() {
@Override
public Iterator<String> doRun(DNSApiManager mgr) {
ListCredentials listCredentials = (ListCredentials) credentials;
assertThat(((X509Certificate) listCredentials.get(0)).getSubjectDN().getName())
.containsIgnoringCase("C=US,ST=California,O=NetflixOSS,OU=Denominator,CN=Denominator");
PrivateKey privateKey = (PrivateKey) listCredentials.get(1);
assertThat(privateKey.getAlgorithm()).isEqualToIgnoringCase("RSA");
assertThat(privateKey.getFormat()).isEqualToIgnoringCase("PKCS#8");
return Collections.<String>emptyList().iterator();
}
};
zoneList.providerConfigurationName = "blah";
zoneList.providerName = "mock";
Map configFromYaml = zoneList.getConfigFromYaml(
zoneList.getFileContentsFromPath(getTestConfigPath("test-config-cert.yml")));
Map credentials = Map.class.cast(configFromYaml.get("credentials"));
zoneList.credentialArgs = asList(credentials.get("x509Certificate").toString(),
credentials.get("privateKey").toString());
zoneList.run();
}
private String getTestConfigPath() {
return getTestConfigPath("test-config.yml");
}
private String getTestConfigPath(String fileName) {
URL res = getClass().getClassLoader().getResource(fileName);
return res != null ? res.getFile() : null;
}
@Test // denominator -p mock record -z denominator.io. list
public void testResourceRecordSetList() {
ResourceRecordSetList command = new ResourceRecordSetList();
command.zoneIdOrName = "denominator.io.";
assertThat(command.doRun(mgr)).containsExactly(
"a.denominator.io. A alazona null 192.0.2.1",
"denominator.io. NS 86400 ns1.denominator.io.",
"denominator.io. SOA 86400 ns1.denominator.io. nil@denominator.io. 1 3600 600 604800 86400",
"server1.denominator.io. CERT 3600 12345 1 1 B33F",
"server1.denominator.io. SRV 3600 0 1 80 www.denominator.io.",
"www.geo.denominator.io. CNAME alazona 86400 a.denominator.io.",
"www.geo.denominator.io. CNAME allElse 600 b.denominator.io.",
"www1.denominator.io. A 3600 192.0.2.1\n"
+ "www1.denominator.io. A 3600 192.0.2.2");
}
@Test // denominator -p mock record -z denominator.io. list -n server1.denominator.io.
public void testResourceRecordSetListByName() {
ResourceRecordSetList command = new ResourceRecordSetList();
command.zoneIdOrName = "denominator.io.";
command.name = "server1.denominator.io.";
assertThat(command.doRun(mgr)).containsExactly(
"server1.denominator.io. CERT 3600 12345 1 1 B33F",
"server1.denominator.io. SRV 3600 0 1 80 www.denominator.io.");
}
@Test // denominator -p mock record -z denominator.io. list -n server1.denominator.io. -t SRV
public void testResourceRecordSetListByNameAndType() {
ResourceRecordSetList command = new ResourceRecordSetList();
command.zoneIdOrName = "denominator.io.";
command.name = "server1.denominator.io.";
command.type = "CERT";
assertThat(command.doRun(mgr)).containsExactly(
"server1.denominator.io. CERT 3600 12345 1 1 B33F");
}
@Test // denominator -p mock record -z denominator.io. get -n server1.denominator.io. -t SRV
public void testResourceRecordSetGetWhenPresent() {
ResourceRecordSetGet command = new ResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "server1.denominator.io.";
command.type = "CERT";
assertThat(command.doRun(mgr)).containsExactly(
"server1.denominator.io. CERT 3600 12345 1 1 B33F");
}
@Test
public void testResourceRecordSetGet_longName() {
ResourceRecordSetGet command = new ResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = new String(new char[51 - 16]).replace("\0", "a") + ".denominator.io.";
command.type = "A";
mgr.api().basicRecordSetsInZone(command.zoneIdOrName).put(a(command.name, asList("192.0.1.1")));
assertThat(command.doRun(mgr)).containsExactly(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.denominator.io. A null 192.0.1.1");
}
@Test
public void testResourceRecordSetGet_longType() {
ResourceRecordSetGet command = new ResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "server1.denominator.io.";
command.type = "IPSECKEY";
command.qualifier = "mavenlover"; // just to ensure type doesn't overrun
Map<String, Object> rdata = new LinkedHashMap<String, Object>();
rdata.put("precedence", 1);
rdata.put("gatetype", 0);
rdata.put("algorithm", 0);
rdata.put("gateway", "foo.");
rdata.put("public_key", "AAAAB3");
mgr.api().recordSetsInZone(command.zoneIdOrName).put(
ResourceRecordSet.builder()
.name(command.name)
.type(command.type)
.qualifier(command.qualifier)
.add(rdata).build());
assertThat(command.doRun(mgr)).containsExactly(
"server1.denominator.io. IPSECKEY mavenlover null 1 0 0 foo. AAAAB3");
}
@Test
public void testResourceRecordSetGet_longTtl() {
ResourceRecordSetGet command = new ResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "server1.denominator.io.";
command.type = "A";
mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.put(a(command.name, 99999999, asList("192.0.1.1")));
assertThat(command.doRun(mgr)).containsExactly(
"server1.denominator.io. A 99999999 192.0.1.1");
}
@Test
public void testResourceRecordSetGet_longQualifier() {
ResourceRecordSetGet command = new ResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "server1.denominator.io.";
command.type = "A";
command.qualifier = new String(new char[21]).replace("\0", "a");
mgr.api().recordSetsInZone(command.zoneIdOrName).put(
ResourceRecordSet.<AData>builder()
.name(command.name)
.type(command.type)
.qualifier(command.qualifier)
.add(AData.create("192.0.1.1")).build());
assertThat(command.doRun(mgr)).containsExactly(
"server1.denominator.io. A aaaaaaaaaaaaaaaaaaaaa null 192.0.1.1");
}
@Test // denominator -p mock record -z denominator.io. get -n www3.denominator.io. -t A
public void testResourceRecordSetGetWhenAbsent() {
ResourceRecordSetGet command = new ResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "www3.denominator.io.";
command.type = "A";
assertThat(command.doRun(mgr)).containsExactly("");
}
@Test
// denominator -p mock record -z denominator.io. get -n www.geo.denominator.io. -t CNAME -g alazona
public void testResourceRecordSetGetWhenQualifierPresent() {
ResourceRecordSetGet command = new ResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "www.geo.denominator.io.";
command.type = "CNAME";
command.qualifier = "alazona";
assertThat(command.doRun(mgr)).containsExactly(
"www.geo.denominator.io. CNAME alazona 86400 a.denominator.io. {\"United States\":[\"AK\",\"AZ\"]}");
}
@Test
// denominator -p mock record -z denominator.io. get -n b.denominator.io. -t A -g alazona
public void testResourceRecordSetGetWhenQualifierAbsent() {
ResourceRecordSetGet command = new ResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "b.denominator.io.";
command.type = "A";
command.qualifier = "alazona";
assertThat(command.doRun(mgr)).containsExactly("");
}
@Test // denominator -p mock record -z denominator.io. applyttl -n www3.denominator.io. -t A 10000
public void testResourceRecordSetApplyTTL() {
ResourceRecordSetApplyTTL command = new ResourceRecordSetApplyTTL();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.ttl = 10000;
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. applying ttl 10000 to rrset www1.denominator.io. A",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type))
.contains(ResourceRecordSet.<AData>builder()
.name(command.name)
.type(command.type)
.ttl(command.ttl)
.add(AData.create("192.0.2.1"))
.add(AData.create("192.0.2.2")).build());
}
@Test
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t A -d 192.0.2.1 -d 192.0.2.2
public void resourceRecordSetAdd() {
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.values = asList("192.0.2.1", "192.0.2.2");
// Ensure the rrset didn't formerly exist.
mgr.api().basicRecordSetsInZone(command.zoneIdOrName).deleteByNameAndType(command.name,
command.type);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding to rrset www1.denominator.io. A values: [{address=192.0.2.1}, {address=192.0.2.2}]",
";; ok");
assertThat(mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.getByNameAndType(command.name, command.type))
.containsExactlyRecords(AData.create("192.0.2.1"), AData.create("192.0.2.2"));
}
@Test
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t A -d 192.0.2.1 -d 192.0.2.2
public void resourceRecordSetAdd_addsOne() {
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.values = asList("192.0.2.1", "192.0.2.2");
// Setup base record with only one value.
mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.put(a(command.name, asList(command.values.get(0))));
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding to rrset www1.denominator.io. A values: [{address=192.0.2.1}, {address=192.0.2.2}]",
";; ok");
assertThat(mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.getByNameAndType(command.name, command.type))
.containsExactlyRecords(AData.create("192.0.2.1"), AData.create("192.0.2.2"));
}
@Test
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t A -d 192.0.2.1 -d 192.0.2.2
public void resourceRecordSetAdd_whenRecordsAlreadyExist() {
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.values = asList("192.0.2.1", "192.0.2.2");
// Setup base record which already has the values.
mgr.api().basicRecordSetsInZone(command.zoneIdOrName).put(a(command.name, command.values));
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding to rrset www1.denominator.io. A values: [{address=192.0.2.1}, {address=192.0.2.2}]",
";; ok");
assertThat(mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.getByNameAndType(command.name, command.type))
.containsExactlyRecords(AData.create("192.0.2.1"), AData.create("192.0.2.2"));
}
@Test
// denominator -p route53 record -z denominator.io. add -n www3.denominator.io. -t A --elb-dnsname nccp-cbp-frontend-12345678.us-west-2.elb.amazonaws.com.
public void testResourceRecordSetAddELBAlias() {
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www3.denominator.io.";
command.type = "A";
command.elbDNSName = "nccp-cbp-frontend-12345678.us-west-2.elb.amazonaws.com.";
AliasTarget
target =
AliasTarget
.create(ResourceRecordSetAdd.REGION_TO_HOSTEDZONE.get("us-west-2"), command.elbDNSName);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding to rrset www3.denominator.io. A values: [" + target
+ "]",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type))
.contains(ResourceRecordSet.<AliasTarget>builder()
.name(command.name)
.type(command.type)
.add(target).build());
}
@Test
// denominator -p route53 record -z denominator.io. replace -n www4.denominator.io. -t A --elb-dnsname nccp-cbp-frontend-12345678.us-west-2.elb.amazonaws.com.
public void testResourceRecordSetReplaceELBAlias() {
ResourceRecordSetReplace command = new ResourceRecordSetReplace();
command.zoneIdOrName = "denominator.io.";
command.name = "www4.denominator.io.";
command.type = "A";
command.elbDNSName = "nccp-cbp-frontend-12345678.us-west-2.elb.amazonaws.com.";
AliasTarget
target =
AliasTarget.create(ResourceRecordSetReplace.REGION_TO_HOSTEDZONE.get("us-west-2"),
command.elbDNSName);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. replacing rrset www4.denominator.io. A with values: [" + target
+ "]",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type))
.contains(
ResourceRecordSet.<AliasTarget>builder()
.name(command.name)
.type(command.type)
.add(target).build());
}
@Test
// denominator -p route53 record -z AAAAAAAA replace -n cbp.nccp.us-east-1.dynprod.netflix.net. -t A --alias-hosted-zone-id BBBBBBBB --alias-dnsname cbp.nccp.us-west-2.dynprod.netflix.net.
public void testResourceRecordSetReplaceRoute53Alias() {
ResourceRecordSetReplace command = new ResourceRecordSetReplace();
command.zoneIdOrName = "denominator.io.";
command.name = "cbp.nccp.us-east-1.dynprod.netflix.net.";
command.type = "A";
command.aliasHostedZoneId = "Z3I0BTR7N27QRM";
command.aliasDNSName = "cbp.nccp.us-west-2.dynprod.netflix.net.";
AliasTarget target = AliasTarget.create(command.aliasHostedZoneId, command.aliasDNSName);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. replacing rrset cbp.nccp.us-east-1.dynprod.netflix.net. A with values: ["
+ target + "]",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type))
.contains(
ResourceRecordSet.<AliasTarget>builder()
.name(command.name)
.type(command.type)
.add(target).build());
}
@Test
public void testResourceRecordSetReplaceRoute53AliasForgotZone() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("--alias-hosted-zone-id must be present");
ResourceRecordSetReplace command = new ResourceRecordSetReplace();
command.zoneIdOrName = "denominator.io.";
command.name = "cbp.nccp.us-east-1.dynprod.netflix.net.";
command.type = "A";
command.aliasDNSName = "cbp.nccp.us-west-2.dynprod.netflix.net.";
command.doRun(mgr);
}
@Test
public void testResourceRecordSetReplaceRoute53AliasZoneNameInsteadOfZoneId() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("--alias-hosted-zone-id must be a hosted zone id, not a zone name");
ResourceRecordSetReplace command = new ResourceRecordSetReplace();
command.zoneIdOrName = "denominator.io.";
command.name = "cbp.nccp.us-east-1.dynprod.netflix.net.";
command.type = "A";
command.aliasHostedZoneId = "denominator.io.";
command.aliasDNSName = "cbp.nccp.us-west-2.dynprod.netflix.net.";
command.doRun(mgr);
}
@Test
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t A --ttl 3600 -d 192.0.2.1 -d 192.0.2.2
public void testResourceRecordSetAddWithTTL() {
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.ttl = 3600;
command.values = asList("192.0.2.1", "192.0.2.2");
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding to rrset www1.denominator.io. A values: [{address=192.0.2.1}, {address=192.0.2.2}] applying ttl 3600",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type))
.contains(ResourceRecordSet.<AData>builder()
.name(command.name)
.type(command.type)
.ttl(command.ttl)
.add(AData.create("192.0.2.1"))
.add(AData.create("192.0.2.2")).build());
}
@Test
// denominator -p mock record -z denominator.io. replace -n www1.denominator.io. -t A -d 192.0.2.1 -d 192.0.2.2
public void testResourceRecordSetReplace() {
ResourceRecordSetReplace command = new ResourceRecordSetReplace();
command.zoneIdOrName = "denominator.io.";
command.name = "www.denominator.io.";
command.type = "CNAME";
command.values = asList("www1.denominator.io.", "www2.denominator.io.");
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. replacing rrset www.denominator.io. CNAME with values: [{cname=www1.denominator.io.}, {cname=www2.denominator.io.}]",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type))
.contains(ResourceRecordSet.<CNAMEData>builder()
.name(command.name)
.type(command.type)
.add(CNAMEData.create("www1.denominator.io."))
.add(CNAMEData.create("www2.denominator.io.")).build());
}
@Test
// denominator -p mock record -z denominator.io. replace -n www1.denominator.io. -t A --ttl 3600 -d 192.0.2.1 -d 192.0.2.2
public void testResourceRecordSetReplaceWithTTL() {
ResourceRecordSetReplace command = new ResourceRecordSetReplace();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.ttl = 3600;
command.values = asList("192.0.2.1", "192.0.2.2");
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. replacing rrset www1.denominator.io. A with values: [{address=192.0.2.1}, {address=192.0.2.2}] and ttl 3600",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type))
.contains(ResourceRecordSet.<AData>builder()
.name(command.name)
.type(command.type)
.ttl(command.ttl)
.add(AData.create("192.0.2.1"))
.add(AData.create("192.0.2.2")).build());
}
@Test
// denominator -p mock record -z denominator.io. remove -n www1.denominator.io. -t A -d 192.0.2.1 -d 192.0.2.2
public void testResourceRecordSetRemove() {
ResourceRecordSetRemove command = new ResourceRecordSetRemove();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.values = asList("192.0.2.1", "192.0.2.2");
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. removing from rrset www1.denominator.io. A values: [{address=192.0.2.1}, {address=192.0.2.2}]",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type)).isEmpty();
}
@Test
// denominator -p mock record -z denominator.io. remove -n www1.denominator.io. -t A -d 192.0.2.1 -d 192.0.2.2
public void resourceRecordSetRemove() {
ResourceRecordSetRemove command = new ResourceRecordSetRemove();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.values = asList("192.0.2.1", "192.0.2.2");
// Setup base record which has both values.
mgr.api().basicRecordSetsInZone(command.zoneIdOrName).put(a(command.name, command.values));
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. removing from rrset www1.denominator.io. A values: [{address=192.0.2.1}, {address=192.0.2.2}]",
";; ok");
assertThat(mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.getByNameAndType(command.name, command.type)).isNull();
}
@Test
// denominator -p mock record -z denominator.io. remove -n www1.denominator.io. -t A -d 192.0.2.2
public void resourceRecordSetRemove_removesOne() {
ResourceRecordSetRemove command = new ResourceRecordSetRemove();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.values = asList("192.0.2.2");
// Setup base record which has two values.
mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.put(a(command.name, asList("192.0.2.1", "192.0.2.2")));
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. removing from rrset www1.denominator.io. A values: [{address=192.0.2.2}]",
";; ok");
assertThat(mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.getByNameAndType(command.name, command.type))
.containsExactlyRecords(AData.create("192.0.2.1"));
}
@Test
// denominator -p mock record -z denominator.io. remove -n www1.denominator.io. -t A -d 192.0.2.1 -d 192.0.2.2
public void resourceRecordSetRemove_whenDoesntExist() {
ResourceRecordSetRemove command = new ResourceRecordSetRemove();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.values = asList("192.0.2.1", "192.0.2.2");
// Setup base record which already has the values.
mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.deleteByNameAndType(command.name, command.type);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. removing from rrset www1.denominator.io. A values: [{address=192.0.2.1}, {address=192.0.2.2}]",
";; ok");
assertThat(mgr.api().basicRecordSetsInZone(command.zoneIdOrName)
.getByNameAndType(command.name, command.type)).isNull();
}
@Test // denominator -p mock record -z denominator.io. delete -n www3.denominator.io. -t A
public void testResourceRecordSetDelete() {
ResourceRecordSetDelete command = new ResourceRecordSetDelete();
command.zoneIdOrName = "denominator.io.";
command.name = "www3.denominator.io.";
command.type = "A";
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. deleting rrset www3.denominator.io. A",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.iterateByNameAndType(command.name, command.type)).isEmpty();
}
@Test // denominator -p mock geo -z denominator.io. types
public void testGeoTypeList() {
GeoTypeList command = new GeoTypeList();
command.zoneIdOrName = "denominator.io.";
assertThat(command.doRun(mgr)).containsExactly(
"A", "AAAA", "CERT", "CNAME", "MX", "NAPTR", "NS", "PTR", "SPF", "SRV", "SSHFP", "TXT");
}
@Test // denominator -p mock geo -z denominator.io. regions
public void testGeoRegionList() {
GeoRegionList command = new GeoRegionList();
command.zoneIdOrName = "denominator.io.";
assertThat(command.doRun(mgr)).containsExactly(
"United States : AL;AK;AS;AZ;AR;AA;AE;AP;CA;CO;CT;DE;DC;FM;FL;GA;GU;HI;ID;IL;IN;IA;KS;KY;LA;ME;MH;MD;MA;MI;MN;MS;MO;MT;NE;NV;NH;NJ;NM;NY;NC;ND;MP;OH;OK;OR;PW;PA;PR;RI;SC;SD;TN;TX;UT;VT;VI;VA;WA;WV;WI;WY",
"Mexico : AG;CM;CP;CH;CA;CL;DU;GJ;GR;HI;JA;MX;MC;MR;NA;OA;PU;QE;SI;SO;TB;TM;TL;VE;YU;ZA"
);
}
@Test // denominator -p mock geo -z denominator.io. list
@Deprecated
public void testGeoResourceRecordSetList() {
GeoResourceRecordSetList command = new GeoResourceRecordSetList();
command.zoneIdOrName = "denominator.io.";
assertThat(command.doRun(mgr)).containsExactly(
"a.denominator.io. A alazona null 192.0.2.1 {\"United States\":[\"AK\",\"AZ\"]}",
"www.geo.denominator.io. CNAME alazona 86400 a.denominator.io. {\"United States\":[\"AK\",\"AZ\"]}",
"www.geo.denominator.io. CNAME allElse 600 b.denominator.io. {\"United States\":[\"AL\",\"AS\",\"AR\",\"AA\",\"AE\",\"AP\",\"CA\",\"CO\",\"CT\",\"DE\",\"DC\",\"FM\",\"FL\",\"GA\",\"GU\",\"HI\",\"ID\",\"IL\",\"IN\",\"IA\",\"KS\",\"KY\",\"LA\",\"ME\",\"MH\",\"MD\",\"MA\",\"MI\",\"MN\",\"MS\",\"MO\",\"MT\",\"NE\",\"NV\",\"NH\",\"NJ\",\"NM\",\"NY\",\"NC\",\"ND\",\"MP\",\"OH\",\"OK\",\"OR\",\"PW\",\"PA\",\"PR\",\"RI\",\"SC\",\"SD\",\"TN\",\"TX\",\"UT\",\"VT\",\"VI\",\"VA\",\"WA\",\"WV\",\"WI\",\"WY\"],\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]}");
}
@Test // denominator -p mock geo -z denominator.io. list -n www.geo.denominator.io.
@Deprecated
public void testGeoResourceRecordSetListByName() {
GeoResourceRecordSetList command = new GeoResourceRecordSetList();
command.zoneIdOrName = "denominator.io.";
command.name = "www.geo.denominator.io.";
assertThat(command.doRun(mgr)).containsExactly(
"www.geo.denominator.io. CNAME alazona 86400 a.denominator.io. {\"United States\":[\"AK\",\"AZ\"]}",
"www.geo.denominator.io. CNAME allElse 600 b.denominator.io. {\"United States\":[\"AL\",\"AS\",\"AR\",\"AA\",\"AE\",\"AP\",\"CA\",\"CO\",\"CT\",\"DE\",\"DC\",\"FM\",\"FL\",\"GA\",\"GU\",\"HI\",\"ID\",\"IL\",\"IN\",\"IA\",\"KS\",\"KY\",\"LA\",\"ME\",\"MH\",\"MD\",\"MA\",\"MI\",\"MN\",\"MS\",\"MO\",\"MT\",\"NE\",\"NV\",\"NH\",\"NJ\",\"NM\",\"NY\",\"NC\",\"ND\",\"MP\",\"OH\",\"OK\",\"OR\",\"PW\",\"PA\",\"PR\",\"RI\",\"SC\",\"SD\",\"TN\",\"TX\",\"UT\",\"VT\",\"VI\",\"VA\",\"WA\",\"WV\",\"WI\",\"WY\"],\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]}");
}
@Test // denominator -p mock geo -z denominator.io. list -n www.geo.denominator.io. -t CNAME
@Deprecated
public void testGeoResourceRecordSetListByNameAndType() {
GeoResourceRecordSetList command = new GeoResourceRecordSetList();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
assertThat(command.doRun(mgr)).containsExactly(
"a.denominator.io. A alazona null 192.0.2.1 {\"United States\":[\"AK\",\"AZ\"]}");
}
@Test
// denominator -p mock geo -z denominator.io. get -n www.geo.denominator.io. -t CNAME -g alazona
@Deprecated
public void testGeoResourceRecordSetGetWhenPresent() {
GeoResourceRecordSetGet command = new GeoResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "www.geo.denominator.io.";
command.type = "CNAME";
command.group = "alazona";
assertThat(command.doRun(mgr)).containsExactly(
"www.geo.denominator.io. CNAME alazona 86400 a.denominator.io. {\"United States\":[\"AK\",\"AZ\"]}");
}
@Test // denominator -p mock geo -z denominator.io. get -n a.denominator.io. -t A -g alazona
@Deprecated
public void testGeoResourceRecordSetGetWhenAbsent() {
GeoResourceRecordSetGet command = new GeoResourceRecordSetGet();
command.zoneIdOrName = "denominator.io.";
command.name = "www.geo.denominator.io.";
command.type = "A";
command.group = "alazona";
assertThat(command.doRun(mgr)).containsExactly("");
}
@Test
// denominator -p mock geo -z denominator.io. applyttl -n a.denominator.io. -t A -g alazona 10000
@Deprecated
public void testGeoResourceRecordSetApplyTTL() {
GeoResourceRecordSetApplyTTL command = new GeoResourceRecordSetApplyTTL();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
command.group = "alazona";
command.ttl = 10000;
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. applying ttl 10000 to rrset a.denominator.io. A alazona",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.getByNameTypeAndQualifier(command.name, command.type, command.group))
.hasTtl(command.ttl);
}
@Test
// denominator -p mock geo -z denominator.io. add -n a.denominator.io. -t A -g alazona -r '{"Mexico":["AG","CM","CP","CH","CA","CL","DU","GJ","GR","HI","JA","MX","MC","MR","NA","OA","PU","QE","SI","SO","TB","TM","TL","VE","YU","ZA"]}'
public void testGeoResourceRecordSetAddRegionsEntireRegion() {
GeoResourceRecordAddRegions command = new GeoResourceRecordAddRegions();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
command.group = "alazona";
command.regions =
"{\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]}";
AllProfileResourceRecordSetApi api = mgr.api().recordSetsInZone(command.zoneIdOrName);
ResourceRecordSet<?>
old =
api.getByNameTypeAndQualifier(command.name, command.type, command.group);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding regions {\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]} to rrset a.denominator.io. A alazona",
";; current rrset: {\"name\":\"a.denominator.io.\",\"type\":\"A\",\"qualifier\":\"alazona\",\"records\":[{\"address\":\"192.0.2.1\"}],\"geo\":{\"regions\":{\"United States\":[\"AK\",\"AZ\"]}}}",
";; revised rrset: {\"name\":\"a.denominator.io.\",\"type\":\"A\",\"qualifier\":\"alazona\",\"records\":[{\"address\":\"192.0.2.1\"}],\"geo\":{\"regions\":{\"United States\":[\"AK\",\"AZ\"],\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]}}}",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.getByNameTypeAndQualifier(command.name, command.type, command.group))
.containsRegion("United States", "AK", "AZ")
.containsRegion("Mexico", mexicanStates(command));
api.put(old);
}
@Test
// denominator -p mock geo -z denominator.io. add -n a.denominator.io. -t A -g alazona -r '{"United States":["AZ"]}'
public void testGeoResourceRecordSetAddRegionsSkipsWhenSame() {
GeoResourceRecordAddRegions command = new GeoResourceRecordAddRegions();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
command.group = "alazona";
command.regions = "{\"United States\":[\"AZ\"]}";
AllProfileResourceRecordSetApi api = mgr.api().recordSetsInZone(command.zoneIdOrName);
ResourceRecordSet<?>
old =
api.getByNameTypeAndQualifier(command.name, command.type, command.group);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding regions {\"United States\":[\"AZ\"]} to rrset a.denominator.io. A alazona",
";; current rrset: {\"name\":\"a.denominator.io.\",\"type\":\"A\",\"qualifier\":\"alazona\",\"records\":[{\"address\":\"192.0.2.1\"}],\"geo\":{\"regions\":{\"United States\":[\"AK\",\"AZ\"]}}}",
";; ok");
assertThat(
mgr.api().recordSetsInZone(command.zoneIdOrName)
.getByNameTypeAndQualifier(command.name, command.type, command.group)).isEqualTo(old);
}
@Test
// denominator -p mock geo -z denominator.io. add -n a.denominator.io. -t A -g alazona -r '{"Mexico":["AG","CM","CP","CH","CA","CL","DU","GJ","GR","HI","JA","MX","MC","MR","NA","OA","PU","QE","SI","SO","TB","TM","TL","VE","YU","ZA"], "United States":["MD"]}'
public void testGeoResourceRecordSetAddRegionsEntireRegionAndTerritory() {
GeoResourceRecordAddRegions command = new GeoResourceRecordAddRegions();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
command.group = "alazona";
command.regions =
"{\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"], \"United States\":[\"MD\"]}";
AllProfileResourceRecordSetApi api = mgr.api().recordSetsInZone(command.zoneIdOrName);
ResourceRecordSet<?>
old =
api.getByNameTypeAndQualifier(command.name, command.type, command.group);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding regions {\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"], \"United States\":[\"MD\"]} to rrset a.denominator.io. A alazona",
";; current rrset: {\"name\":\"a.denominator.io.\",\"type\":\"A\",\"qualifier\":\"alazona\",\"records\":[{\"address\":\"192.0.2.1\"}],\"geo\":{\"regions\":{\"United States\":[\"AK\",\"AZ\"]}}}",
";; revised rrset: {\"name\":\"a.denominator.io.\",\"type\":\"A\",\"qualifier\":\"alazona\",\"records\":[{\"address\":\"192.0.2.1\"}],\"geo\":{\"regions\":{\"United States\":[\"AK\",\"AZ\",\"MD\"],\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]}}}",
";; ok");
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.getByNameTypeAndQualifier(command.name, command.type, command.group))
.containsRegion("United States", "AK", "AZ", "MD")
.containsRegion("Mexico", mexicanStates(command));
api.put(old);
}
@Test
// denominator -p mock geo -z denominator.io. add -n a.denominator.io. -t A -g alazona -r '{"Mexico":["AG","CM","CP","CH","CA","CL","DU","GJ","GR","HI","JA","MX","MC","MR","NA","OA","PU","QE","SI","SO","TB","TM","TL","VE","YU","ZA"]}' --dry-run --validate-regions
public void testGeoResourceRecordSetAddRegionsEntireRegionAndTerritoryValidatedDryRun() {
GeoResourceRecordAddRegions command = new GeoResourceRecordAddRegions();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
command.group = "alazona";
command.regions =
"{\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]}";
command.validateRegions = true;
command.dryRun = true;
AllProfileResourceRecordSetApi api = mgr.api().recordSetsInZone(command.zoneIdOrName);
ResourceRecordSet<?>
old =
api.getByNameTypeAndQualifier(command.name, command.type, command.group);
assertThat(command.doRun(mgr)).containsExactly(
";; in zone denominator.io. adding regions {\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]} to rrset a.denominator.io. A alazona",
";; validated regions: {\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]}",
";; current rrset: {\"name\":\"a.denominator.io.\",\"type\":\"A\",\"qualifier\":\"alazona\",\"records\":[{\"address\":\"192.0.2.1\"}],\"geo\":{\"regions\":{\"United States\":[\"AK\",\"AZ\"]}}}",
";; revised rrset: {\"name\":\"a.denominator.io.\",\"type\":\"A\",\"qualifier\":\"alazona\",\"records\":[{\"address\":\"192.0.2.1\"}],\"geo\":{\"regions\":{\"United States\":[\"AK\",\"AZ\"],\"Mexico\":[\"AG\",\"CM\",\"CP\",\"CH\",\"CA\",\"CL\",\"DU\",\"GJ\",\"GR\",\"HI\",\"JA\",\"MX\",\"MC\",\"MR\",\"NA\",\"OA\",\"PU\",\"QE\",\"SI\",\"SO\",\"TB\",\"TM\",\"TL\",\"VE\",\"YU\",\"ZA\"]}}}",
";; ok");
assertThat(
mgr.api().recordSetsInZone(command.zoneIdOrName)
.getByNameTypeAndQualifier(command.name, command.type, command.group)).isEqualTo(old);
}
@Test
// denominator -p mock geo -z denominator.io. add -n a.denominator.io. -t A -g alazona -r {\"Mexico\":[\"Ru\"]} --validate-regions
public void testGeoResourceRecordSetAddRegionsValidationFailureOnTerritory() {
GeoResourceRecordAddRegions command = new GeoResourceRecordAddRegions();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
command.group = "alazona";
command.regions = "{\"Mexico\":[\"Ru\"]}";
command.validateRegions = true;
AllProfileResourceRecordSetApi api = mgr.api().recordSetsInZone(command.zoneIdOrName);
ResourceRecordSet<?>
old =
api.getByNameTypeAndQualifier(command.name, command.type, command.group);
try {
Iterator<String> iterator = command.doRun(mgr);
assertThat(iterator.next())
.isEqualTo(
";; in zone denominator.io. adding regions {\"Mexico\":[\"Ru\"]} to rrset a.denominator.io. A alazona");
iterator.next();
fail("should have failed on validation");
} catch (IllegalArgumentException e) {
assertThat(e).hasMessage("unsupported territories in Mexico: [[Ru]]");
}
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.getByNameTypeAndQualifier(command.name, command.type, command.group))
.isEqualTo(old);
}
@Test
// denominator -p mock geo -z denominator.io. add -n a.denominator.io. -t A -g alazona -r {\"Mexico\":[\"Mexico\"],\"Suth America\":[\"Ecuador\"]} --validate-regions
public void testGeoResourceRecordSetAddRegionsValidationFailureOnRegion() {
GeoResourceRecordAddRegions command = new GeoResourceRecordAddRegions();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
command.group = "alazona";
command.regions = "{\"Mexico\":[\"AG\"],\"Suth America\":[\"EC\"]}";
command.validateRegions = true;
AllProfileResourceRecordSetApi api = mgr.api().recordSetsInZone(command.zoneIdOrName);
ResourceRecordSet<?>
old =
api.getByNameTypeAndQualifier(command.name, command.type, command.group);
try {
Iterator<String> iterator = command.doRun(mgr);
assertThat(iterator.next())
.isEqualTo(
";; in zone denominator.io. adding regions {\"Mexico\":[\"AG\"],\"Suth America\":[\"EC\"]} to rrset a.denominator.io. A alazona");
iterator.next();
fail("should have failed on validation");
} catch (IllegalArgumentException e) {
assertThat(e).hasMessage("unsupported regions: [Suth America]");
}
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.getByNameTypeAndQualifier(command.name, command.type, command.group))
.isEqualTo(old);
}
@Test
// denominator -p mock geo -z denominator.io. add -n a.denominator.io. -t A -g alazona -r Mexico
public void testGeoResourceRecordSetAddRegionsBadJson() {
GeoResourceRecordAddRegions command = new GeoResourceRecordAddRegions();
command.zoneIdOrName = "denominator.io.";
command.name = "a.denominator.io.";
command.type = "A";
command.group = "alazona";
command.regions = "Mexico";
AllProfileResourceRecordSetApi api = mgr.api().recordSetsInZone(command.zoneIdOrName);
ResourceRecordSet<?>
old =
api.getByNameTypeAndQualifier(command.name, command.type, command.group);
try {
command.doRun(mgr);
fail("should have failed on bad json");
} catch (IllegalArgumentException e) {
assertThat(e).hasMessage(
"parse failure on regions! check json syntax. ex. {\"United States\":[\"AZ\"]}");
}
assertThat(mgr.api().recordSetsInZone(command.zoneIdOrName)
.getByNameTypeAndQualifier(command.name, command.type, command.group))
.isEqualTo(old);
}
@Test
public void testProxySettingsWithPort() {
Denominator.DenominatorCommand.setProtocolProxyFromEnv("http", "http://localhost:7878");
Denominator.DenominatorCommand.setProtocolProxyFromEnv("https", "https://10.0.0.1:8989");
assertThat(System.getProperty("http.proxyHost")).isEqualTo("localhost");
assertThat(System.getProperty("http.proxyPort")).isEqualTo("7878");
assertThat(System.getProperty("https.proxyHost")).isEqualTo("10.0.0.1");
assertThat(System.getProperty("https.proxyPort")).isEqualTo("8989");
}
@Test
public void testProxySettingsWithDefaultPorts() {
Denominator.DenominatorCommand.setProtocolProxyFromEnv("http", "http://localhost");
Denominator.DenominatorCommand.setProtocolProxyFromEnv("https", "https://10.0.0.1");
assertThat(System.getProperty("http.proxyHost")).isEqualTo("localhost");
assertThat(System.getProperty("http.proxyPort")).isEqualTo("80");
assertThat(System.getProperty("https.proxyHost")).isEqualTo("10.0.0.1");
assertThat(System.getProperty("https.proxyPort")).isEqualTo("443");
}
@Test
public void testProxySettingsFromProperties() {
System.setProperty("http.proxyHost", "192.168.0.1");
System.setProperty("https.proxyHost", "192.168.0.2");
Denominator.DenominatorCommand.setProtocolProxyFromEnv("http", "http://localhost");
Denominator.DenominatorCommand.setProtocolProxyFromEnv("https", "https://10.0.0.1");
assertThat(System.getProperty("http.proxyHost")).isEqualTo("192.168.0.1");
assertThat(System.getProperty("http.proxyPort")).isNull();
assertThat(System.getProperty("https.proxyHost")).isEqualTo("192.168.0.2");
assertThat(System.getProperty("https.proxyPort")).isNull();
}
@Test
public void testInvalidEnvProxySettings() {
exit.expectSystemExitWithStatus(1);
exit.checkAssertionAfterwards(new Assertion() {
@Override
public void checkAssertion() throws Exception {
assertThat(System.getProperty("http.proxyHost")).isEqualTo("localhost");
assertThat(System.getProperty("http.proxyPort")).isEqualTo("80");
assertThat(System.getProperty("https.proxyHost")).isNull();
assertThat(System.getProperty("https.proxyPort")).isNull();
assertThat(systemErrRule.getLog())
.isEqualToIgnoringCase(
"invalid https proxy configuration: no protocol: 10.0.0.1:8443\n");
}
});
Denominator.DenominatorCommand.setProtocolProxyFromEnv("http", "http://localhost");
Denominator.DenominatorCommand.setProtocolProxyFromEnv("https", "10.0.0.1:8443");
}
@Before
public void stockRecords() {
{
ResourceRecordSetApi api = mgr.api().basicRecordSetsInZone("denominator.io.");
api.put(a("www1.denominator.io.", 3600, asList("192.0.2.1", "192.0.2.2")));
api.put(srv("server1.denominator.io.", 3600, "0 1 80 www.denominator.io."));
api.put(cert("server1.denominator.io.", 3600, "12345 1 1 B33F"));
}
AllProfileResourceRecordSetApi api = mgr.api().recordSetsInZone("denominator.io.");
Map<String, Collection<String>> alazona = new LinkedHashMap<String, Collection<String>>();
alazona.put("United States", asList("AK", "AZ"));
api.put(ResourceRecordSet.builder()
.name("a.denominator.io.")
.type("A")
.qualifier("alazona")
.add(AData.create("192.0.2.1"))
.geo(Geo.create(alazona)).build());
api.put(ResourceRecordSet.builder().name("www.geo.denominator.io.")
.type("CNAME")
.qualifier("alazona")
.ttl(86400)
.add(CNAMEData.create("a.denominator.io."))
.geo(Geo.create(alazona)).build());
Map<String, Collection<String>> allElse = new LinkedHashMap<String, Collection<String>>();
allElse.putAll(mgr.api().geoRecordSetsInZone("denominator.io.").supportedRegions());
Collection<String> us = new LinkedHashSet<String>(allElse.get("United States"));
us.removeAll(alazona.get("United States"));
allElse.put("United States", us);
api.put(ResourceRecordSet.builder().name("www.geo.denominator.io.")
.type("CNAME")
.qualifier("allElse")
.ttl(600)
.add(CNAMEData.create("b.denominator.io."))
.geo(Geo.create(allElse)).build());
}
private String[] mexicanStates(GeoResourceRecordAddRegions command) {
return mgr.api().geoRecordSetsInZone(command.zoneIdOrName).supportedRegions().get("Mexico")
.toArray(new String[]{});
}
}
| 145 |
0 | Create_ds/denominator/cli/src/test/java/denominator | Create_ds/denominator/cli/src/test/java/denominator/cli/DataFromInstanceMetadataHookTest.java | package denominator.cli;
import com.squareup.okhttp.mockwebserver.MockResponse;
import com.squareup.okhttp.mockwebserver.MockWebServer;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import denominator.DNSApiManager;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetAdd;
import denominator.hook.InstanceMetadataHook;
import denominator.mock.MockProvider;
import static com.squareup.okhttp.mockwebserver.SocketPolicy.SHUTDOWN_INPUT_AT_END;
import static denominator.assertj.MockWebServerAssertions.assertThat;
public class DataFromInstanceMetadataHookTest {
@Rule
public final MockWebServer server = new MockWebServer();
@Rule
public final ExpectedException thrown = ExpectedException.none();
DNSApiManager mgr = denominator.Denominator.create(new MockProvider());
@Test(timeout = 3000)
public void testInstanceMetadataHookDoesntHangMoreThan3Seconds() throws Exception {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("could not retrieve public-hostname from http://");
server.enqueue(new MockResponse().setSocketPolicy(SHUTDOWN_INPUT_AT_END));
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "CNAME";
command.ec2PublicHostname = true;
command.metadataService = server.getUrl(InstanceMetadataHook.DEFAULT_URI.getPath()).toURI();
command.doRun(mgr);
}
@Test
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t CNAME --ec2-public-hostname"
public void testEC2PublicHostnameFlag() throws Exception {
server.enqueue(new MockResponse().setBody("ec2-50-17-85-234.compute-1.amazonaws.com"));
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "CNAME";
command.ec2PublicHostname = true;
command.metadataService = server.getUrl(InstanceMetadataHook.DEFAULT_URI.getPath()).toURI();
assertThat(command.doRun(mgr))
.containsExactly(
";; in zone denominator.io. adding to rrset www1.denominator.io. CNAME values: [{cname=ec2-50-17-85-234.compute-1.amazonaws.com}]",
";; ok");
assertThat(server.takeRequest())
.hasMethod("GET")
.hasPath("/latest/meta-data/public-hostname");
}
@Test
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t A --ec2-public-ipv4
public void testEC2PublicIpv4Flag() throws Exception {
server.enqueue(new MockResponse().setBody("50.17.85.234"));
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.ec2PublicIpv4 = true;
command.metadataService = server.getUrl(InstanceMetadataHook.DEFAULT_URI.getPath()).toURI();
assertThat(command.doRun(mgr))
.containsExactly(
";; in zone denominator.io. adding to rrset www1.denominator.io. A values: [{address=50.17.85.234}]",
";; ok");
assertThat(server.takeRequest())
.hasMethod("GET")
.hasPath("/latest/meta-data/public-ipv4");
}
@Test(timeout = 3000)
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t A --ec2-public-ipv4
public void testEC2PublicIpv4FlagWhenFailsDoesntHangMoreThan3Seconds() throws Exception {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("could not retrieve public-ipv4 from http://");
server.enqueue(new MockResponse().setSocketPolicy(SHUTDOWN_INPUT_AT_END));
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.ec2PublicIpv4 = true;
command.metadataService = server.getUrl(InstanceMetadataHook.DEFAULT_URI.getPath()).toURI();
command.doRun(mgr);
}
@Test
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t CNAME --ec2-local-hostname
public void testEC2LocalHostnameFlag() throws Exception {
server.enqueue(new MockResponse().setBody("domU-12-31-39-02-14-35.compute-1.internal"));
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "CNAME";
command.ec2LocalHostname = true;
command.metadataService = server.getUrl(InstanceMetadataHook.DEFAULT_URI.getPath()).toURI();
assertThat(command.doRun(mgr))
.containsExactly(
";; in zone denominator.io. adding to rrset www1.denominator.io. CNAME values: [{cname=domU-12-31-39-02-14-35.compute-1.internal}]",
";; ok");
assertThat(server.takeRequest())
.hasMethod("GET")
.hasPath("/latest/meta-data/local-hostname");
}
@Test
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t A --ec2-local-ipv4
public void testEC2LocalIpv4Flag() throws Exception {
server.enqueue(new MockResponse().setBody("10.248.27.195"));
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.ec2LocalIpv4 = true;
command.metadataService = server.getUrl(InstanceMetadataHook.DEFAULT_URI.getPath()).toURI();
assertThat(command.doRun(mgr))
.containsExactly(
";; in zone denominator.io. adding to rrset www1.denominator.io. A values: [{address=10.248.27.195}]",
";; ok");
assertThat(server.takeRequest())
.hasMethod("GET")
.hasPath("/latest/meta-data/local-ipv4");
}
@Test(timeout = 3000)
// denominator -p mock record -z denominator.io. add -n www1.denominator.io. -t A --ec2-local-ipv4
public void testEC2LocalIpv4FlagWhenFailsDoesntHangMoreThan3Seconds() throws Exception {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("could not retrieve local-ipv4 from http://");
server.enqueue(new MockResponse().setSocketPolicy(SHUTDOWN_INPUT_AT_END));
ResourceRecordSetAdd command = new ResourceRecordSetAdd();
command.zoneIdOrName = "denominator.io.";
command.name = "www1.denominator.io.";
command.type = "A";
command.ec2LocalIpv4 = true;
command.metadataService = server.getUrl(InstanceMetadataHook.DEFAULT_URI.getPath()).toURI();
command.doRun(mgr);
}
}
| 146 |
0 | Create_ds/denominator/cli/src/main/java/denominator | Create_ds/denominator/cli/src/main/java/denominator/cli/ResourceRecordSetCommands.java | package denominator.cli;
import com.google.common.base.Function;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import denominator.DNSApiManager;
import denominator.ResourceRecordSetApi;
import denominator.cli.Denominator.DenominatorCommand;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordSetToString;
import denominator.common.Util;
import denominator.hook.InstanceMetadataHook;
import denominator.model.ResourceRecordSet;
import denominator.model.ResourceRecordSet.Builder;
import denominator.route53.AliasTarget;
import io.airlift.airline.Arguments;
import io.airlift.airline.Command;
import io.airlift.airline.Option;
import io.airlift.airline.OptionType;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.collect.Iterators.concat;
import static com.google.common.collect.Iterators.forArray;
import static com.google.common.collect.Iterators.singletonIterator;
import static com.google.common.collect.Iterators.transform;
import static denominator.cli.Denominator.id;
import static denominator.common.Util.join;
import static java.lang.String.format;
class ResourceRecordSetCommands {
enum ResourceRecordSetToString implements Function<ResourceRecordSet<?>, String> {
INSTANCE;
@Override
public String apply(ResourceRecordSet<?> input) {
List<String> lines = new ArrayList<String>();
for (Map<String, Object> rdata : input.records()) {
lines.add(format("%-49s %-6s %-19s %-5s %s", input.name(), input.type(),
input.qualifier() != null ? input.qualifier() : "", input.ttl(),
Util.flatten(rdata)));
}
return join('\n', lines.toArray());
}
}
private static abstract class ResourceRecordSetCommand extends DenominatorCommand {
@Option(type = OptionType.GROUP, required = true, name = {"-z",
"--zone"}, description = "zone name (or id if ambiguous) to affect. ex. denominator.io. or EXFHEDD")
public String zoneIdOrName;
}
@Command(name = "list", description = "Lists the record record sets present in this zone")
public static class ResourceRecordSetList extends ResourceRecordSetCommand {
@Option(type = OptionType.COMMAND, name = {"-n",
"--name"}, description = "name of the record sets. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, name = {"-t",
"--type"}, description = "type of the record set. ex. CNAME")
public String type;
public Iterator<String> doRun(DNSApiManager mgr) {
Iterator<ResourceRecordSet<?>> iterator;
String zoneId = id(mgr, zoneIdOrName);
if (type != null) {
iterator = mgr.api().recordSetsInZone(zoneId).iterateByNameAndType(name, type);
} else if (name != null) {
iterator = mgr.api().recordSetsInZone(zoneId).iterateByName(name);
} else {
iterator = mgr.api().recordSetsInZone(zoneId).iterator();
}
return transform(iterator, ResourceRecordSetToString.INSTANCE);
}
}
@Command(name = "get", description = "gets a record record set by name and type (optionally by qualifier), if present in this zone")
public static class ResourceRecordSetGet extends ResourceRecordSetCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-n",
"--name"}, description = "name of the record set. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, required = true, name = {"-t",
"--type"}, description = "type of the record set. ex. CNAME")
public String type;
@Option(type = OptionType.COMMAND, name = {"-q",
"--qualifier"}, description = "qualifier of the record set (if applicable). ex. US")
public String qualifier;
public Iterator<String> doRun(DNSApiManager mgr) {
ResourceRecordSet<?> rrs;
String zoneId = id(mgr, zoneIdOrName);
if (qualifier != null) {
rrs = mgr.api().recordSetsInZone(zoneId).getByNameTypeAndQualifier(name, type, qualifier);
} else {
rrs = mgr.api().basicRecordSetsInZone(zoneId).getByNameAndType(name, type);
}
return rrs != null ? singletonIterator(GeoResourceRecordSetToString.INSTANCE.apply(rrs))
: singletonIterator("");
}
}
@Command(name = "applyttl", description = "applies the ttl to the record record set by name and type, if present in this zone")
public static class ResourceRecordSetApplyTTL extends ResourceRecordSetCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-n",
"--name"}, description = "name of the record set. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, required = true, name = {"-t",
"--type"}, description = "type of the record set. ex. CNAME")
public String type;
@Arguments(required = true, description = "time to live of the record set. ex. 300")
public int ttl;
public Iterator<String> doRun(final DNSApiManager mgr) {
String
cmd =
format(";; in zone %s applying ttl %d to rrset %s %s", zoneIdOrName, ttl, name, type);
return concat(forArray(cmd), new Iterator<String>() {
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
ResourceRecordSetApi api = mgr.api().basicRecordSetsInZone(id(mgr, zoneIdOrName));
ResourceRecordSet<?> rrs = api.getByNameAndType(name, type);
if (rrs != null && rrs.ttl() != null && rrs.ttl().intValue() != ttl) {
api.put(ResourceRecordSet.builder()
.name(rrs.name())
.type(rrs.type())
.ttl(ttl)
.addAll(rrs.records()).build());
}
done = true;
return ";; ok";
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
});
}
}
private static abstract class ModifyRecordSetCommand extends ResourceRecordSetCommand {
static final Pattern
ELB_REGION =
Pattern.compile("[^.]+\\.([^.]+)\\.elb\\.amazonaws\\.com\\.?");
static final Map<String, String> REGION_TO_HOSTEDZONE;
static {
LinkedHashMap<String, String> regionToHostedZone = new LinkedHashMap<String, String>();
regionToHostedZone.put("us-east-1", "Z3DZXE0Q79N41H");
regionToHostedZone.put("us-west-2", "Z33MTJ483KN6FU");
regionToHostedZone.put("eu-west-1", "Z3NF1Z3NOM5OY2");
regionToHostedZone.put("ap-northeast-1", "Z2YN17T5R711GT");
regionToHostedZone.put("ap-southeast-1", "Z1WI8VXHPB1R38");
regionToHostedZone.put("sa-east-1", "Z2ES78Y61JGQKS");
REGION_TO_HOSTEDZONE = Collections.unmodifiableMap(regionToHostedZone);
}
@Option(type = OptionType.COMMAND, required = true, name = {"-n",
"--name"}, description = "name of the record set. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, required = true, name = {"-t",
"--type"}, description = "type of the record set. ex. CNAME")
public String type;
@Option(type = OptionType.COMMAND, required = false, name = {"-d",
"--data"}, description = "repeat for each record value (rdata) to add. ex. 192.0.2.1")
public List<String> values = new ArrayList<String>();
@Option(type = OptionType.COMMAND, required = false, name = "--ec2-public-ipv4", description = "take data from EC2 Instance Metadata public-ipv4")
public boolean ec2PublicIpv4;
@Option(type = OptionType.COMMAND, required = false, name = "--ec2-public-hostname", description = "take data from EC2 Instance Metadata public-hostname")
public boolean ec2PublicHostname;
@Option(type = OptionType.COMMAND, required = false, name = "--ec2-local-ipv4", description = "take data from EC2 Instance Metadata local-ipv4")
public boolean ec2LocalIpv4;
@Option(type = OptionType.COMMAND, required = false, name = "--ec2-local-hostname", description = "take data from EC2 Instance Metadata local-hostname")
public boolean ec2LocalHostname;
@Option(type = OptionType.COMMAND, required = false, name = "--alias-hosted-zone-id", description = "hosted zone id of the AWS resource to alias. ex. Z3DZXE0Q79N41H")
public String aliasHostedZoneId;
@Option(type = OptionType.COMMAND, required = false, name = "--alias-dnsname", description = "dnsname of the AWS resource to alias. ex. nccp-cbp-frontend-12345678.us-west-2.elb.amazonaws.com.")
public String aliasDNSName;
@Option(type = OptionType.COMMAND, required = false, name = "--elb-dnsname", description = "dnsname of the ELB to alias. ex. nccp-cbp-frontend-12345678.us-west-2.elb.amazonaws.com.")
public String elbDNSName;
public URI metadataService = InstanceMetadataHook.DEFAULT_URI;
/**
* @throws IllegalArgumentException if an ec2 instance metadata hook was requested, but the
* service could not be contacted.
*/
protected Builder<Map<String, Object>> rrsetBuilder() throws IllegalArgumentException {
if (ec2PublicIpv4) {
addIfPresentInMetadataService("public-ipv4");
} else if (ec2PublicHostname) {
addIfPresentInMetadataService("public-hostname");
} else if (ec2LocalIpv4) {
addIfPresentInMetadataService("local-ipv4");
} else if (ec2LocalHostname) {
addIfPresentInMetadataService("local-hostname");
}
checkArgument(aliasDNSName != null || elbDNSName != null || !values.isEmpty(),
"you must pass data to add");
Builder<Map<String, Object>> builder = ResourceRecordSet.builder().name(name).type(type);
if (aliasDNSName != null) {
checkArgument(aliasHostedZoneId != null, "--alias-hosted-zone-id must be present");
checkArgument(aliasHostedZoneId.indexOf('.') == -1,
"--alias-hosted-zone-id must be a hosted zone id, not a zone name");
builder.add(AliasTarget.create(aliasHostedZoneId, aliasDNSName));
} else if (elbDNSName != null) {
Matcher getRegion = ELB_REGION.matcher(elbDNSName);
checkArgument(getRegion.matches(), "expected elb %s to match %s", ELB_REGION, elbDNSName);
String hostedZoneId = REGION_TO_HOSTEDZONE.get(getRegion.group(1));
checkArgument(hostedZoneId != null, "region %s not in configured regions: %s",
getRegion.group(1),
REGION_TO_HOSTEDZONE.keySet());
builder.add(AliasTarget.create(hostedZoneId, elbDNSName));
} else {
for (String value : values) {
builder.add(Util.toMap(type, value));
}
}
return builder;
}
/**
* @throws IllegalArgumentException if an ec2 instance metadata hook was requested, but the
* service could not be contacted.
*/
private void addIfPresentInMetadataService(String key) {
String value = InstanceMetadataHook.get(metadataService, key);
checkArgument(value != null, "could not retrieve %s from %s", key, metadataService);
values.add(value);
}
}
@Command(name = "add", description = "creates or adds data to a record set corresponding to name and type. sets ttl, if present")
public static class ResourceRecordSetAdd extends ModifyRecordSetCommand {
@Option(type = OptionType.COMMAND, name = "--ttl", description = "time to live of the record set. ex. 300")
public int ttl = -1;
public Iterator<String> doRun(final DNSApiManager mgr) {
Builder<Map<String, Object>> builder = rrsetBuilder();
if (ttl != -1) {
builder.ttl(ttl);
}
final ResourceRecordSet<Map<String, Object>> toAdd = builder.build();
String cmd =
format(";; in zone %s adding to rrset %s %s values: %s", zoneIdOrName, name, type,
join(',', toAdd.records()));
if (ttl != -1) {
cmd = format("%s applying ttl %d", cmd, ttl);
}
return concat(forArray(cmd), new Iterator<String>() {
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
ResourceRecordSetApi api = mgr.api().basicRecordSetsInZone(id(mgr, zoneIdOrName));
ResourceRecordSet<?> rrset = api.getByNameAndType(name, type);
if (rrset != null) {
Set<Map<String, Object>> data = new LinkedHashSet<Map<String, Object>>(rrset.records());
if (data.addAll(toAdd.records())) {
api.put(ResourceRecordSet.builder()
.name(rrset.name())
.type(rrset.type())
.ttl(rrset.ttl())
.addAll(data).build());
}
} else {
api.put(toAdd);
}
done = true;
return ";; ok";
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
});
}
}
@Command(name = "replace", description = "creates or replaces data in a record set corresponding to name and type. sets ttl, if present")
public static class ResourceRecordSetReplace extends ModifyRecordSetCommand {
@Option(type = OptionType.COMMAND, name = "--ttl", description = "time to live of the record set. ex. 300")
public int ttl = -1;
public Iterator<String> doRun(final DNSApiManager mgr) {
Builder<Map<String, Object>> builder = rrsetBuilder();
if (ttl != -1) {
builder.ttl(ttl);
}
final ResourceRecordSet<Map<String, Object>> toAdd = builder.build();
String
cmd =
format(";; in zone %s replacing rrset %s %s with values: %s", zoneIdOrName, name, type,
join(',', toAdd.records()));
if (ttl != -1) {
cmd = format("%s and ttl %d", cmd, ttl);
}
return concat(forArray(cmd), new Iterator<String>() {
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
mgr.api().basicRecordSetsInZone(id(mgr, zoneIdOrName)).put(toAdd);
done = true;
return ";; ok";
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
});
}
}
@Command(name = "remove", description = "removes data from a record set corresponding to name and type.")
public static class ResourceRecordSetRemove extends ModifyRecordSetCommand {
public Iterator<String> doRun(final DNSApiManager mgr) {
final ResourceRecordSet<Map<String, Object>> toRemove = rrsetBuilder().build();
String
cmd =
format(";; in zone %s removing from rrset %s %s values: %s", zoneIdOrName, name, type,
join(',', toRemove.records()));
return concat(forArray(cmd), new Iterator<String>() {
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
ResourceRecordSetApi api = mgr.api().basicRecordSetsInZone(id(mgr, zoneIdOrName));
ResourceRecordSet<?> rrset = api.getByNameAndType(name, type);
if (rrset != null) {
Set<Map<String, Object>> data = new LinkedHashSet<Map<String, Object>>(rrset.records());
if (data.removeAll(toRemove.records())) {
if (data.isEmpty()) {
api.deleteByNameAndType(name, type);
} else {
api.put(ResourceRecordSet.builder()
.name(rrset.name())
.type(rrset.type())
.ttl(rrset.ttl())
.addAll(data).build());
}
}
}
done = true;
return ";; ok";
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
});
}
}
@Command(name = "delete", description = "deletes a record record set by name and type, if present in this zone")
public static class ResourceRecordSetDelete extends ResourceRecordSetCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-n",
"--name"}, description = "name of the record set. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, required = true, name = {"-t",
"--type"}, description = "type of the record set. ex. CNAME")
public String type;
public Iterator<String> doRun(final DNSApiManager mgr) {
String cmd = format(";; in zone %s deleting rrset %s %s", zoneIdOrName, name, type);
return concat(forArray(cmd), new Iterator<String>() {
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
mgr.api().basicRecordSetsInZone(id(mgr, zoneIdOrName)).deleteByNameAndType(name, type);
done = true;
return ";; ok";
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
});
}
}
}
| 147 |
0 | Create_ds/denominator/cli/src/main/java/denominator | Create_ds/denominator/cli/src/main/java/denominator/cli/GeoResourceRecordSetCommands.java | package denominator.cli;
import com.google.common.base.Function;
import com.google.common.base.Splitter;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.MapDifference;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.common.collect.Sets.SetView;
import com.google.gson.reflect.TypeToken;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import denominator.DNSApiManager;
import denominator.cli.Denominator.DenominatorCommand;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetToString;
import denominator.model.ResourceRecordSet;
import denominator.profile.GeoResourceRecordSetApi;
import io.airlift.airline.Arguments;
import io.airlift.airline.Command;
import io.airlift.airline.Option;
import io.airlift.airline.OptionType;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.collect.Iterators.concat;
import static com.google.common.collect.Iterators.forArray;
import static com.google.common.collect.Iterators.singletonIterator;
import static com.google.common.collect.Iterators.transform;
import static denominator.cli.Denominator.id;
import static denominator.cli.Denominator.json;
import static denominator.common.Util.join;
import static denominator.model.profile.Geos.withAdditionalRegions;
import static java.lang.String.format;
class GeoResourceRecordSetCommands {
static void validateRegions(Map<String, Collection<String>> regionsToAdd,
Map<String, Collection<String>> supportedRegions) {
MapDifference<String, Collection<String>>
comparison =
Maps.difference(regionsToAdd, supportedRegions);
checkArgument(comparison.entriesOnlyOnLeft().isEmpty(), "unsupported regions: %s", comparison
.entriesOnlyOnLeft().keySet());
for (Entry<String, Collection<String>> entry : regionsToAdd.entrySet()) {
ImmutableSet<String> toAdd = ImmutableSet.copyOf(entry.getValue());
SetView<String> intersection = Sets.intersection(toAdd,
ImmutableSet.copyOf(
supportedRegions.get(entry.getKey())));
SetView<String> unsupported = Sets.difference(toAdd, intersection);
checkArgument(unsupported.isEmpty(), "unsupported territories in %s:", entry.getKey(),
unsupported);
}
}
enum GeoResourceRecordSetToString implements Function<ResourceRecordSet<?>, String> {
INSTANCE;
@Override
public String apply(ResourceRecordSet<?> rrset) {
List<String> lines = new ArrayList<String>();
for (String line : Splitter.on('\n').split(ResourceRecordSetToString.INSTANCE.apply(rrset))) {
if (rrset.geo() != null) {
lines.add(new StringBuilder().append(line).append(' ')
.append(json.toJson(rrset.geo().regions()))
.toString());
} else {
lines.add(line);
}
}
return join('\n', lines.toArray());
}
}
private static abstract class GeoResourceRecordSetCommand extends DenominatorCommand {
@Option(type = OptionType.GROUP, required = true, name = {"-z",
"--zone"}, description = "zone name (or id if ambiguous) to affect. ex. denominator.io. or EXFHEDD")
public String zoneIdOrName;
}
@Command(name = "types", description = "Lists the record types that support geo profile in this zone")
public static class GeoTypeList extends GeoResourceRecordSetCommand {
@Override
protected Iterator<String> doRun(DNSApiManager mgr) {
return mgr.provider().profileToRecordTypes().get("geo").iterator();
}
}
@Command(name = "regions", description = "Lists the geo regions supported in this zone")
public static class GeoRegionList extends GeoResourceRecordSetCommand {
@Override
protected Iterator<String> doRun(DNSApiManager mgr) {
return FluentIterable
.from(mgr.api().geoRecordSetsInZone(id(mgr, zoneIdOrName)).supportedRegions()
.entrySet())
.transform(new Function<Map.Entry<String, Collection<String>>, String>() {
@Override
public String apply(Entry<String, Collection<String>> input) {
return format("%-28s: %s", input.getKey(), join(';', input.getValue().toArray()));
}
}).iterator();
}
}
@Command(name = "list", description = "Lists the geo record record sets present in this zone")
public static class GeoResourceRecordSetList extends GeoResourceRecordSetCommand {
@Option(type = OptionType.COMMAND, name = {"-n",
"--name"}, description = "name of the record sets. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, name = {"-t",
"--type"}, description = "type of the record set. (must be present with name) ex. CNAME")
public String type;
public Iterator<String> doRun(DNSApiManager mgr) {
Iterator<ResourceRecordSet<?>> iterator;
if (name != null && type != null) {
iterator =
mgr.api().geoRecordSetsInZone(id(mgr, zoneIdOrName))
.iterateByNameAndType(name, type);
} else if (name != null) {
iterator = mgr.api().geoRecordSetsInZone(id(mgr, zoneIdOrName)).iterateByName(name);
} else {
iterator = mgr.api().geoRecordSetsInZone(id(mgr, zoneIdOrName)).iterator();
}
return transform(iterator, GeoResourceRecordSetToString.INSTANCE);
}
}
@Command(name = "get", description = "Lists the geo record record set by name, type, and group, if present in this zone")
public static class GeoResourceRecordSetGet extends GeoResourceRecordSetCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-n",
"--name"}, description = "name of the record set. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, required = true, name = {"-t",
"--type"}, description = "type of the record set. ex. CNAME")
public String type;
@Option(type = OptionType.COMMAND, required = true, name = {"-g",
"--group"}, description = "geo group of the record set. ex. US")
public String group;
public Iterator<String> doRun(DNSApiManager mgr) {
GeoResourceRecordSetApi api = mgr.api().geoRecordSetsInZone(id(mgr, zoneIdOrName));
ResourceRecordSet<?> rrs = api.getByNameTypeAndQualifier(name, type, group);
return rrs != null ? singletonIterator(GeoResourceRecordSetToString.INSTANCE.apply(rrs))
: singletonIterator("");
}
}
@Command(name = "applyttl", description = "applies the ttl to the record record set by name, type and group, if present in this zone")
public static class GeoResourceRecordSetApplyTTL extends GeoResourceRecordSetCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-n",
"--name"}, description = "name of the record set. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, required = true, name = {"-t",
"--type"}, description = "type of the record set. ex. CNAME")
public String type;
@Option(type = OptionType.COMMAND, required = true, name = {"-g",
"--group"}, description = "geo group of the record set. ex. US")
public String group;
@Arguments(required = true, description = "time to live of the record set. ex. 300")
public int ttl;
public Iterator<String> doRun(final DNSApiManager mgr) {
String
cmd =
format(";; in zone %s applying ttl %d to rrset %s %s %s", zoneIdOrName, ttl, name, type,
group);
return concat(forArray(cmd), new Iterator<String>() {
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
GeoResourceRecordSetApi api = mgr.api().geoRecordSetsInZone(id(mgr, zoneIdOrName));
ResourceRecordSet<?> rrs = api.getByNameTypeAndQualifier(name, type, group);
if (rrs != null &&
(rrs.ttl() == null || (rrs.ttl() != null && rrs.ttl().intValue() != ttl))) {
api.put(ResourceRecordSet.<Map<String, Object>>builder()
.name(name)
.type(type)
.qualifier(group)
.ttl(ttl)
.weighted(rrs.weighted())
.geo(rrs.geo())
.addAll(rrs.records()).build());
}
done = true;
return ";; ok";
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
});
}
}
@Command(name = "add", description = "adds the regions or territories specified to the geo record set")
public static class GeoResourceRecordAddRegions extends GeoResourceRecordSetCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-n",
"--name"}, description = "name of the record set. ex. www.denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, required = true, name = {"-t",
"--type"}, description = "type of the record set. ex. CNAME")
public String type;
@Option(type = OptionType.COMMAND, required = true, name = {"-g",
"--group"}, description = "geo group of the record set. ex. US-WEST-2")
public String group;
@Option(type = OptionType.COMMAND, required = true, name = {"-r",
"--regions"}, description = "regions to add in json. ex. {\"Mexico\":[\"CM\"],\"United States\":[\"AZ\"]}")
public String regions;
@Option(type = OptionType.COMMAND, required = false, name = {
"--dry-run"}, description = "when true, don't actually perform the update")
public Boolean dryRun;
@Option(type = OptionType.COMMAND, required = false, name = {
"--validate-regions"}, description = "when true, check to ensure that the regions specified are indeed supported")
public Boolean validateRegions;
public Iterator<String> doRun(final DNSApiManager mgr) {
checkArgument(!regions.isEmpty(), "specify regions to apply");
// resolve into a concrete zone id or name.
zoneIdOrName = id(mgr, zoneIdOrName);
final GeoResourceRecordSetApi api = mgr.api().geoRecordSetsInZone(zoneIdOrName);
checkArgument(api != null, "geo api not available on provider %s, zone %s", mgr.provider(),
zoneIdOrName);
String
cmd =
format(";; in zone %s adding regions %s to rrset %s %s %s", zoneIdOrName, regions, name,
type,
group);
final Map<String, Collection<String>> regionsToAdd = parseRegions();
return concat(forArray(cmd), new Iterator<String>() {
boolean validatedRegions;
ResourceRecordSet<?> existing = null;
ResourceRecordSet<?> update = null;
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
if (Boolean.TRUE.equals(validateRegions) && !validatedRegions) {
validateRegions(regionsToAdd, api.supportedRegions());
validatedRegions = true;
return ";; validated regions: " + json.toJson(regionsToAdd);
} else if (existing == null) {
existing = api.getByNameTypeAndQualifier(name, type, group);
return ";; current rrset: " + json.toJson(existing);
} else if (update == null) {
update = withAdditionalRegions(existing, regionsToAdd);
if (update == existing) {
done = true;
return ";; ok";
}
return ";; revised rrset: " + json.toJson(update);
} else {
if (!Boolean.TRUE.equals(dryRun)) {
api.put(update);
}
done = true;
return ";; ok";
}
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
});
}
private Map<String, Collection<String>> parseRegions() {
try {
return json.fromJson(regions, new TypeToken<Map<String, Collection<String>>>() {
}.getType());
} catch (RuntimeException e) {
throw new IllegalArgumentException(
"parse failure on regions! check json syntax. ex. {\"United States\":[\"AZ\"]}", e);
}
}
}
}
| 148 |
0 | Create_ds/denominator/cli/src/main/java/denominator | Create_ds/denominator/cli/src/main/java/denominator/cli/ZoneCommands.java | package denominator.cli;
import com.google.common.base.Function;
import com.google.common.collect.Iterators;
import java.util.Iterator;
import denominator.DNSApiManager;
import denominator.cli.Denominator.DenominatorCommand;
import denominator.model.Zone;
import io.airlift.airline.Command;
import io.airlift.airline.Option;
import io.airlift.airline.OptionType;
import static com.google.common.collect.Iterators.concat;
import static com.google.common.collect.Iterators.forArray;
import static java.lang.String.format;
class ZoneCommands {
@Command(name = "list", description = "Lists the zones present in this provider. The zone id is the first column.")
public static class ZoneList extends DenominatorCommand {
@Option(type = OptionType.COMMAND, name = {"-n",
"--name"}, description = "name of the zone. ex. denominator.io.")
public String name;
public Iterator<String> doRun(final DNSApiManager mgr) {
Iterator<Zone> zones =
name == null ? mgr.api().zones().iterator() : mgr.api().zones().iterateByName(name);
return Iterators.transform(zones, new Function<Zone, String>() {
@Override
public String apply(Zone input) {
return format("%-24s %-36s %-36s %d", input.id(), input.name(), input.email(),
input.ttl());
}
});
}
}
@Command(name = "add", description =
"Adds a zone or updates the first existing zone with the same name, outputs the result's id.\n"
+ "Note: This may create a duplicate zone if the provider supports it.")
public static class ZoneAdd extends DenominatorCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-n",
"--name"}, description = "name of the zone. ex. denominator.io.")
public String name;
@Option(type = OptionType.COMMAND, name = {"-t",
"--ttl"}, description = "time to live of the zone (SOA). defaults to 86400")
public int ttl = 86400;
@Option(type = OptionType.COMMAND, required = true, name = {"-e",
"--email"}, description = "Email contact for the zone. ex. admin@denominator.io")
public String email;
public Iterator<String> doRun(final DNSApiManager mgr) {
final Zone zone = Zone.create(null, name, ttl, email);
return new Iterator<String>() {
boolean printed = false;
boolean replaced = false;
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
if (!printed) {
printed = true;
String context = zone.name() + (zone.id() == null ? "" : " [" + zone.id() + "]");
return format(";; adding zone %s with ttl %d and email %s", context, ttl, email);
} else if (!replaced) {
replaced = true;
return mgr.api().zones().put(zone);
} else {
done = true;
return ";; ok";
}
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
}
@Command(name = "update", description = "Updates an existing zone with the specified ttl and/or email.")
public static class ZoneUpdate extends DenominatorCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-i",
"--id"}, description = "id of the zone.")
public String id;
@Option(type = OptionType.COMMAND, name = {"-t",
"--ttl"}, description = "time to live of the zone (SOA)")
public Integer ttl;
@Option(type = OptionType.COMMAND, name = {"-e",
"--email"}, description = "Email contact for the zone. ex. nil@denominator.io")
public String email;
public Iterator<String> doRun(final DNSApiManager mgr) {
final Zone existing = getZone(mgr, id);
final Zone update = Zone.create(id, existing.name(), ttl != null ? ttl : existing.ttl(),
email != null ? email : existing.email());
if (existing.equals(update)) {
return forArray(";; ok");
}
return new Iterator<String>() {
boolean printed = false;
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
if (!printed) {
printed = true;
StringBuilder result = new StringBuilder();
result.append(";; updating zone ").append(existing.id()).append(" with ");
if (ttl != null && email != null) {
result.append("ttl ").append(ttl).append(" and ").append("email ").append(email);
} else if (ttl != null) {
result.append("ttl ").append(ttl);
} else {
result.append("email ").append(email);
}
return result.toString();
} else {
done = true;
mgr.api().zones().put(update);
return ";; ok";
}
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
}
static Zone getZone(DNSApiManager mgr, String id) {
for (Zone zone : mgr.api().zones()) {
if (zone.id().equals(id)) {
return zone; // TODO: consider getById
}
}
throw new IllegalArgumentException("zone " + id + " not found");
}
@Command(name = "delete", description = "deletes a zone by id")
public static class ZoneDelete extends DenominatorCommand {
@Option(type = OptionType.COMMAND, required = true, name = {"-i",
"--id"}, description = "id of the zone.")
public String id;
public Iterator<String> doRun(final DNSApiManager mgr) {
String cmd = format(";; deleting zone %s", id);
return concat(forArray(cmd), new Iterator<String>() {
boolean done = false;
@Override
public boolean hasNext() {
return !done;
}
@Override
public String next() {
mgr.api().zones().delete(id);
done = true;
return ";; ok";
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
});
}
}
}
| 149 |
0 | Create_ds/denominator/cli/src/main/java/denominator | Create_ds/denominator/cli/src/main/java/denominator/cli/Denominator.java | package denominator.cli;
import com.google.common.base.CaseFormat;
import com.google.common.base.Charsets;
import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Joiner;
import com.google.common.base.Predicate;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Ordering;
import com.google.common.io.Files;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.InstanceCreator;
import com.google.gson.TypeAdapter;
import com.google.gson.internal.ConstructorConstructor;
import com.google.gson.internal.bind.MapTypeAdapterFactory;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import dagger.ObjectGraph;
import dagger.Provides;
import denominator.Credentials;
import denominator.Credentials.AnonymousCredentials;
import denominator.Credentials.ListCredentials;
import denominator.Credentials.MapCredentials;
import denominator.DNSApiManager;
import denominator.Denominator.Version;
import denominator.Provider;
import denominator.Providers;
import denominator.cli.GeoResourceRecordSetCommands.GeoRegionList;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordAddRegions;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordSetApplyTTL;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordSetGet;
import denominator.cli.GeoResourceRecordSetCommands.GeoResourceRecordSetList;
import denominator.cli.GeoResourceRecordSetCommands.GeoTypeList;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetAdd;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetApplyTTL;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetDelete;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetGet;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetList;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetRemove;
import denominator.cli.ResourceRecordSetCommands.ResourceRecordSetReplace;
import denominator.cli.ZoneCommands.ZoneAdd;
import denominator.cli.ZoneCommands.ZoneDelete;
import denominator.cli.ZoneCommands.ZoneList;
import denominator.cli.ZoneCommands.ZoneUpdate;
import denominator.dynect.DynECTProvider;
import denominator.model.Zone;
import denominator.ultradns.UltraDNSProvider;
import feign.Logger;
import feign.Logger.Level;
import io.airlift.airline.Cli;
import io.airlift.airline.Cli.CliBuilder;
import io.airlift.airline.Command;
import io.airlift.airline.Help;
import io.airlift.airline.Option;
import io.airlift.airline.OptionType;
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.provider.X509CertParser;
import org.bouncycastle.openssl.PEMKeyPair;
import org.bouncycastle.openssl.PEMParser;
import org.yaml.snakeyaml.Yaml;
import javax.inject.Singleton;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.StringReader;
import java.lang.reflect.Type;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.KeyFactory;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import static com.google.common.base.Preconditions.checkArgument;
import static denominator.CredentialsConfiguration.credentials;
import static java.lang.String.format;
public class Denominator {
static final TypeToken<Map<String, Object>> token = new TypeToken<Map<String, Object>>() {
};
static final TypeAdapter<Map<String, Object>>
doubleToInt =
new TypeAdapter<Map<String, Object>>() {
TypeAdapter<Map<String, Object>>
delegate =
new MapTypeAdapterFactory(new ConstructorConstructor(
Collections.<Type, InstanceCreator<?>>emptyMap()), false).create(new Gson(), token);
@Override
public void write(JsonWriter out, Map<String, Object> value) throws IOException {
delegate.write(out, value);
}
@Override
public Map<String, Object> read(JsonReader in) throws IOException {
Map<String, Object> map = delegate.read(in);
for (Entry<String, Object> entry : map.entrySet()) {
if (entry.getValue() instanceof Double) {
entry.setValue(Double.class.cast(entry.getValue()).intValue());
}
}
return map;
}
}.nullSafe();
// deals with scenario where gson Object type treats all numbers as doubles.
static final Gson
json =
new GsonBuilder().registerTypeAdapter(token.getType(), doubleToInt).create();
public static void main(String[] args) {
CliBuilder<Runnable> builder = Cli.<Runnable>builder("denominator")
.withDescription("Denominator: Portable control of DNS clouds")
.withDefaultCommand(Help.class)
.withCommand(Help.class)
.withCommand(PrintVersion.class)
.withCommand(ListProviders.class);
builder.withGroup("zone")
.withDescription("manage zones")
.withDefaultCommand(ZoneList.class)
.withCommand(ZoneList.class)
.withCommand(ZoneAdd.class)
.withCommand(ZoneUpdate.class)
.withCommand(ZoneDelete.class);
builder.withGroup("record")
.withDescription("manage resource record sets in a zone")
.withDefaultCommand(ResourceRecordSetList.class)
.withCommand(ResourceRecordSetList.class)
.withCommand(ResourceRecordSetGet.class)
.withCommand(ResourceRecordSetAdd.class)
.withCommand(ResourceRecordSetApplyTTL.class)
.withCommand(ResourceRecordSetReplace.class)
.withCommand(ResourceRecordSetRemove.class)
.withCommand(ResourceRecordSetDelete.class);
builder.withGroup("geo")
.withDescription("manage geo resource record sets in a zone")
.withDefaultCommand(GeoResourceRecordSetList.class)
.withCommand(GeoTypeList.class)
.withCommand(GeoRegionList.class)
.withCommand(GeoResourceRecordSetList.class)
.withCommand(GeoResourceRecordSetGet.class)
.withCommand(GeoResourceRecordSetApplyTTL.class)
.withCommand(GeoResourceRecordAddRegions.class);
Cli<Runnable> denominatorParser = builder.build();
try {
denominatorParser.parse(args).run();
} catch (RuntimeException e) {
if (e instanceof NullPointerException) {
e.printStackTrace();
}
System.err.println(";; error: " + e.getMessage());
System.exit(1);
}
System.exit(0);
}
/**
* Returns a log configuration module or null if none is needed.
*/
static Object logModule(boolean quiet, boolean verbose) {
checkArgument(!(quiet && verbose), "quiet and verbose flags cannot be used at the same time!");
Logger.Level logLevel;
if (quiet) {
return null;
} else if (verbose) {
logLevel = Logger.Level.FULL;
} else {
logLevel = Logger.Level.BASIC;
}
return new LogModule(logLevel);
}
static String id(DNSApiManager mgr, String zoneIdOrName) {
if (zoneIdOrName.indexOf('.') == -1) { // Assume that ids don't have dots in them!
return zoneIdOrName;
}
if (zoneNameIsId(mgr.provider())) {
return zoneIdOrName;
}
Iterator<Zone> result = mgr.api().zones().iterateByName(zoneIdOrName);
checkArgument(result.hasNext(), "zone %s not found", zoneIdOrName);
return result.next().id();
}
// Special-case providers known to use zone names as ids, as this usually saves 1-200ms of
// lookups. We can later introduce a flag or other means to help third-party providers.
static boolean zoneNameIsId(Provider provider) {
return provider instanceof UltraDNSProvider || provider instanceof DynECTProvider;
}
@Command(name = "version", description = "output the version of denominator and java runtime in use")
public static class PrintVersion implements Runnable {
public void run() {
System.out.println("Denominator " + Version.INSTANCE);
System.out.println("Java version: " + System.getProperty("java.version"));
}
}
@Command(name = "providers", description = "List the providers and their metadata ")
public static class ListProviders implements Runnable {
final static String table = "%-10s %-51s %-14s %-14s %s%n";
public static String providerAndCredentialsTable() {
StringBuilder builder = new StringBuilder();
builder.append(format(
table, "provider", "url", "duplicateZones", "credentialType", "credentialArgs"));
for (Provider p : ImmutableSortedSet.copyOf(Ordering.usingToString(), Providers.list())) {
if (p.credentialTypeToParameterNames().isEmpty()) {
builder.append(
format("%-10s %-51s %-14s %n", p.name(), p.url(), p.supportsDuplicateZoneNames()));
}
for (Entry<String, Collection<String>> e : p.credentialTypeToParameterNames().entrySet()) {
String params = Joiner.on(' ').join(e.getValue());
builder.append(format(
table, p.name(), p.url(), p.supportsDuplicateZoneNames(), e.getKey(), params));
}
}
return builder.toString();
}
public void run() {
System.out.println(providerAndCredentialsTable());
}
}
public static abstract class DenominatorCommand implements Runnable {
private static final String ENV_PREFIX = "DENOMINATOR_";
@Option(type = OptionType.GLOBAL, name = {"-q",
"--quiet"}, description = "do not emit informational messages about http commands invoked")
public boolean quiet;
@Option(type = OptionType.GLOBAL, name = {"-v",
"--verbose"}, description = "emit details such as http requests sent and responses received")
public boolean verbose;
@Option(type = OptionType.GLOBAL, name = {"-p",
"--provider"}, description = "provider to affect")
public String providerName;
@Option(type = OptionType.GLOBAL, name = {"-u",
"--url"}, description = "alternative api url to connect to")
public String url;
@Option(type = OptionType.GLOBAL, name = {"-c",
"--credential"}, description = "adds a credential argument (execute denominator providers for what these are)")
public List<String> credentialArgs;
@Option(type = OptionType.GLOBAL, name = {"-C",
"--config"}, description = "path to configuration file (used to store credentials). default: ~/.denominatorconfig")
public String configPath = "~/.denominatorconfig";
@Option(type = OptionType.GLOBAL, name = {"-n",
"--configuration-name"}, description = "unique name of provider configuration")
public String providerConfigurationName;
protected Credentials credentials = AnonymousCredentials.INSTANCE;
@SuppressWarnings("unchecked")
public void run() {
setProxyFromEnv();
if (providerName != null && credentialArgs != null) {
credentials = ListCredentials.from(Lists.transform(credentialArgs, decodeAnyPems));
} else if (providerConfigurationName != null) {
Map<?, ?> configFromFile = getConfigFromFile();
if (configFromFile != null) {
credentials = MapCredentials.from(
Maps.transformValues(Map.class.cast(configFromFile.get("credentials")), decodeAnyPems));
providerName = configFromFile.get("provider").toString();
if (configFromFile.containsKey("url")) {
url = configFromFile.get("url").toString();
}
}
} else {
overrideFromEnv(System.getenv());
}
Provider provider = Providers.getByName(providerName);
if (url != null) {
provider = Providers.withUrl(provider, url);
}
Builder<Object> modulesForGraph = ImmutableList.builder() //
.add(Providers.provide(provider)) //
.add(Providers.instantiateModule(provider));
Object logModule = logModule(quiet, verbose);
if (logModule != null) {
modulesForGraph.add(logModule);
}
if (credentials != AnonymousCredentials.INSTANCE) {
modulesForGraph.add(credentials(credentials));
}
DNSApiManager mgr = null;
try {
mgr = ObjectGraph.create(modulesForGraph.build().toArray()).get(DNSApiManager.class);
for (Iterator<String> i = doRun(mgr); i.hasNext(); ) {
System.out.println(i.next());
}
} finally {
if (mgr != null) {
try {
mgr.close();
} catch (IOException ignored) {
}
}
}
}
private static final Function<Object, Object> maybeDecodeX509Pem = new Function<Object, Object>() {
@Override
public Object apply(Object input) {
if (input instanceof String && input.toString().contains("BEGIN CERTIFICATE")) {
try {
X509CertParser x509CertParser = new X509CertParser();
x509CertParser.engineInit(new ByteArrayInputStream(input.toString().getBytes()));
return x509CertParser.engineRead();
} catch (Exception ex) {
return input;
}
}
return input;
}
};
private static final Function<Object, Object> maybeDecodePrivateKeyPem = new Function<Object, Object>() {
@Override
public Object apply(Object input) {
if (input instanceof String && input.toString().contains("BEGIN RSA PRIVATE KEY")) {
try {
PEMKeyPair pemKeyPair = (PEMKeyPair) new PEMParser(new StringReader(input.toString())).readObject();
PrivateKeyInfo privateKeyInfo = pemKeyPair.getPrivateKeyInfo();
KeyFactory keyFact = KeyFactory.getInstance(
privateKeyInfo.getPrivateKeyAlgorithm().getAlgorithm().getId(), new BouncyCastleProvider());
return keyFact.generatePrivate(new PKCS8EncodedKeySpec(privateKeyInfo.getEncoded()));
} catch (Exception ex) {
return input;
}
}
return input;
}
};
private static final Function<Object, Object> decodeAnyPems =
Functions.compose(maybeDecodeX509Pem, maybeDecodePrivateKeyPem);
/**
* Load configuration for given providerConfigurationName from a YAML configuration file.
*/
Map<?, ?> getConfigFromFile() {
if (configPath == null) {
return null;
}
String configFileContent = null;
try {
configFileContent = getFileContentsFromPath(configPath);
} catch (IOException e) {
System.err.println("configuration file not found: " + e.getMessage());
System.exit(1);
}
return getConfigFromYaml(configFileContent);
}
Map<?, ?> getConfigFromYaml(String yamlAsString) {
Yaml yaml = new Yaml();
Iterable<Object> configs = yaml.loadAll(yamlAsString);
Object providerConf = FluentIterable.from(configs).firstMatch(new Predicate<Object>() {
@Override
public boolean apply(Object input) {
return providerConfigurationName.equals(Map.class.cast(input).get("name"));
}
}).get();
return Map.class.cast(providerConf);
}
String getFileContentsFromPath(String path) throws IOException {
if (path.startsWith("~")) {
path = System.getProperty("user.home") + path.substring(1);
}
return Files.toString(new File(path), Charsets.UTF_8);
}
void overrideFromEnv(Map<String, String> env) {
if (providerName == null) {
providerName = env.get(ENV_PREFIX + "PROVIDER");
}
if (url == null) {
url = env.get(ENV_PREFIX + "URL");
}
Provider providerLoaded = Providers.getByName(providerName);
if (providerLoaded != null) {
Map<String, String> credentialMap = new LinkedHashMap<String, String>();
// merge the list of possible credentials
for (Entry<String, Collection<String>> entry :
providerLoaded.credentialTypeToParameterNames().entrySet()) {
for (String paramName : entry.getValue()) {
String
upperParamName =
CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, paramName);
String value = env.get(ENV_PREFIX + upperParamName);
if (value != null) {
credentialMap.put(paramName, value);
}
}
}
if (!credentialMap.isEmpty()) {
credentials = MapCredentials.from(credentialMap);
}
}
}
static void setProxyFromEnv() {
setProtocolProxyFromEnv("http", System.getenv("HTTP_PROXY"));
setProtocolProxyFromEnv("https", System.getenv("HTTPS_PROXY"));
}
static void setProtocolProxyFromEnv(String proto, String envProxy) {
if (envProxy != null && !envProxy.isEmpty()) {
try {
URL proxyUrl = new URL(envProxy);
String proxyHost = System.getProperty(proto + ".proxyHost");
if ((proxyHost == null || proxyHost.isEmpty())) {
System.setProperty(proto + ".proxyHost", proxyUrl.getHost());
System.setProperty(proto + ".proxyPort",
Integer.toString(
proxyUrl.getPort() == -1 ? proxyUrl.getDefaultPort() : proxyUrl.getPort()));
}
} catch (MalformedURLException e) {
System.err.println("invalid " + proto + " proxy configuration: " + e.getMessage());
System.exit(1);
}
}
}
/**
* return a lazy iterator where possible to improve the perceived responsiveness of the cli
*/
protected abstract Iterator<String> doRun(DNSApiManager mgr);
}
@dagger.Module(overrides = true, library = true)
static class LogModule {
final Logger.Level logLevel;
LogModule(Level logLevel) {
this.logLevel = logLevel;
}
@Provides
@Singleton
Logger logger() {
return new Logger.ErrorLogger();
}
@Provides
@Singleton
Logger.Level level() {
return logLevel;
}
}
}
| 150 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSProviderDynamicUpdateMockTest.java | package denominator.clouddns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import java.util.concurrent.atomic.AtomicReference;
import dagger.Module;
import dagger.Provides;
import denominator.Credentials;
import denominator.Credentials.ListCredentials;
import denominator.DNSApi;
import denominator.Denominator;
import static denominator.CredentialsConfiguration.credentials;
public class CloudDNSProviderDynamicUpdateMockTest {
@Rule
public final MockCloudDNSServer server = new MockCloudDNSServer();
@Test
public void dynamicEndpointUpdates() throws Exception {
final AtomicReference<String> url = new AtomicReference<String>(server.url());
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody("{ \"domains\": [] }"));
DNSApi api = Denominator.create(new CloudDNSProvider() {
@Override
public String url() {
return url.get();
}
}, credentials(server.credentials())).api();
api.zones().iterator();
server.assertAuthRequest();
server.assertRequest();
MockCloudDNSServer server2 = new MockCloudDNSServer();
url.set(server2.url());
server2.enqueueAuthResponse();
server2.enqueue(new MockResponse().setBody("{ \"domains\": [] }"));
api.zones().iterator();
server2.assertAuthRequest();
server2.assertRequest();
server2.shutdown();
}
@Test
public void dynamicCredentialUpdates() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody("{ \"domains\": [] }"));
AtomicReference<Credentials>
dynamicCredentials =
new AtomicReference<Credentials>(server.credentials());
DNSApi
api =
Denominator.create(server, new OverrideCredentials(dynamicCredentials)).api();
api.zones().iterator();
server.assertAuthRequest();
server.assertRequest();
dynamicCredentials.set(ListCredentials.from("jclouds-bob", "comeon"));
server.credentials("jclouds-bob", "comeon");
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody("{ \"domains\": [] }"));
api.zones().iterator();
server.assertAuthRequest();
server.assertRequest();
}
@Module(complete = false, library = true, overrides = true)
static class OverrideCredentials {
final AtomicReference<Credentials> dynamicCredentials;
OverrideCredentials(AtomicReference<Credentials> dynamicCredentials) {
this.dynamicCredentials = dynamicCredentials;
}
@Provides
public Credentials get() {
return dynamicCredentials.get();
}
}
}
| 151 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSTestGraph.java | package denominator.clouddns;
import denominator.DNSApiManagerFactory;
import denominator.TestGraph;
import static feign.Util.emptyToNull;
import static java.lang.System.getProperty;
public class CloudDNSTestGraph extends TestGraph {
private static final String url = emptyToNull(getProperty("clouddns.url"));
private static final String zone = emptyToNull(getProperty("clouddns.zone"));
public CloudDNSTestGraph() {
super(DNSApiManagerFactory.create(new CloudDNSProvider(url)), zone);
}
}
| 152 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSZoneWriteCommandsLiveTest.java | package denominator.clouddns;
import denominator.Live.UseTestGraph;
import denominator.ZoneWriteCommandsLiveTest;
@UseTestGraph(CloudDNSTestGraph.class)
public class CloudDNSZoneWriteCommandsLiveTest extends ZoneWriteCommandsLiveTest {
}
| 153 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/MockCloudDNSServer.java | package denominator.clouddns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import com.squareup.okhttp.mockwebserver.MockWebServer;
import com.squareup.okhttp.mockwebserver.MockWebServer;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
import java.io.IOException;
import denominator.Credentials;
import denominator.CredentialsConfiguration;
import denominator.DNSApiManager;
import denominator.Denominator;
import denominator.assertj.RecordedRequestAssert;
import static denominator.Credentials.ListCredentials;
import static denominator.assertj.MockWebServerAssertions.assertThat;
import static java.lang.String.format;
final class MockCloudDNSServer extends CloudDNSProvider implements TestRule {
@dagger.Module(injects = DNSApiManager.class, complete = false, includes =
CloudDNSProvider.Module.class)
static final class Module {
}
private final MockWebServer delegate = new MockWebServer();
private final String tokenId = "b84f4a37-5126-4603-9521-ccd0665fbde1";
private String tenantId = "123123";
private String username = "jclouds-joe";
private String apiKey = "letmein";
private String accessResponse;
MockCloudDNSServer() {
credentials(username, apiKey);
}
String tenantId() {
return tenantId;
}
String tokenId() {
return tokenId;
}
@Override
public String url() {
return "http://localhost:" + delegate.getPort();
}
DNSApiManager connect() {
return Denominator.create(this, CredentialsConfiguration.credentials(credentials()));
}
Credentials credentials() {
return ListCredentials.from(username, apiKey);
}
MockCloudDNSServer credentials(String username, String apiKey) {
this.username = username;
this.apiKey = apiKey;
this.accessResponse = "{\"access\": {\n"
+ " \"token\": {\n"
+ " \"expires\": \"2013-07-08T05:55:31.809Z\",\n"
+ format(" \"id\": \"%s\",\n", tokenId)
+ " \"tenant\": {\n"
+ format(" \"id\": \"%s\",\n", tenantId)
+ " \"name\": \"denominator\"\n"
+ " }\n"
+ " },\n"
+ " \"serviceCatalog\": [\n"
+ " {\n"
+ " \"name\": \"cloudDNS\",\n"
+ " \"type\": \"rax:dns\",\n"
+ " \"endpoints\": [{\n"
+ format(" \"tenantId\": \"%s\",\n", tenantId)
+ format(" \"publicURL\": \"http://localhost:%s\\/v1.0\\/%s\"\n",
delegate.getPort(), tenantId)
+ " }]\n"
+ " }\n"
+ " ]\n"
+ "}}";
return this;
}
void enqueueAuthResponse() {
delegate.enqueue(new MockResponse().setBody(accessResponse));
}
void enqueue(MockResponse mockResponse) {
delegate.enqueue(mockResponse);
}
RecordedRequestAssert assertRequest() throws InterruptedException {
return assertThat(delegate.takeRequest());
}
RecordedRequestAssert assertAuthRequest() throws InterruptedException {
return assertThat(delegate.takeRequest())
.hasMethod("POST")
.hasPath("/tokens")
.hasBody(format(
"{\"auth\":{\"RAX-KSKEY:apiKeyCredentials\":{\"username\":\"%s\",\"apiKey\":\"%s\"}}}",
username, apiKey));
}
void shutdown() throws IOException {
delegate.shutdown();
}
@Override
public Statement apply(Statement base, Description description) {
return delegate.apply(base, description);
}
}
| 154 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSFunctionsTest.java | package denominator.clouddns;
import org.junit.Test;
import denominator.clouddns.RackspaceApis.Record;
import denominator.model.rdata.NSData;
import denominator.model.rdata.TXTData;
import static org.assertj.core.api.Assertions.assertThat;
public class CloudDNSFunctionsTest {
@Test
public void transformsNSRecordSet() {
Record input = new Record();
input.name = "denominator.io";
input.type = "NS";
input.ttl = 3600;
input.data("dns1.stabletransit.com");
assertThat(CloudDNSFunctions.toRDataMap(input))
.isEqualTo(NSData.create("dns1.stabletransit.com"));
}
@Test
public void transformsTXTRecordSet() {
Record input = new Record();
input.name = "denominator.io";
input.type = "TXT";
input.ttl = 3600;
input.data("Hello DNS");
assertThat(CloudDNSFunctions.toRDataMap(input))
.isEqualTo(TXTData.create("Hello DNS"));
}
}
| 155 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/KeystoneAccessAdapterTest.java | package denominator.clouddns;
import com.google.gson.TypeAdapter;
import com.squareup.okhttp.mockwebserver.MockResponse;
import com.squareup.okhttp.mockwebserver.MockWebServer;
import org.junit.Rule;
import org.junit.Test;
import java.util.Arrays;
import denominator.clouddns.RackspaceApis.CloudIdentity;
import denominator.clouddns.RackspaceApis.TokenIdAndPublicURL;
import feign.Feign;
import feign.Target.EmptyTarget;
import feign.gson.GsonDecoder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNull;
public class KeystoneAccessAdapterTest {
@Rule
public final MockWebServer server = new MockWebServer();
CloudIdentity client = Feign.builder()
.decoder(
new GsonDecoder(Arrays.<TypeAdapter<?>>asList(new KeystoneAccessAdapter("rax:dns"))))
.target(EmptyTarget.create(CloudIdentity.class, "cloudidentity"));
@Test
public void publicURLFound() throws Exception {
server.enqueue(new MockResponse().setBody(ACCESS_HEADER
+ " \"name\": \"cloudDNS\",\n"
+ " \"endpoints\": [{\n"
+ " \"tenantId\": \"1234\",\n"
+ " \"publicURL\": \"https:\\/\\/dns.api.rackspacecloud.com\\/v1.0\\/1234\"\n"
+ " }],\n"
+ " \"type\": \"rax:dns\"\n"
+ SERVICE + ACCESS_FOOTER));
TokenIdAndPublicURL result = client.passwordAuth(server.getUrl("/").toURI(), "u", "p");
assertThat(result.tokenId).isEqualTo("1bcd122d87494f5ab39a185b9ec5ff73");
assertThat(result.publicURL)
.isEqualTo("https://dns.api.rackspacecloud.com/v1.0/1234");
}
@Test
public void noEndpoints() throws Exception {
server.enqueue(new MockResponse().setBody(ACCESS_HEADER
+ " \"name\": \"cloudDNS\",\n"
+ " \"type\": \"rax:dns\"\n"
+ SERVICE + ACCESS_FOOTER));
TokenIdAndPublicURL result = client.passwordAuth(server.getUrl("/").toURI(), "u", "p");
assertThat(result.tokenId).isEqualTo("1bcd122d87494f5ab39a185b9ec5ff73");
assertNull(result.publicURL);
}
@Test
public void serviceNotFound() throws Exception {
server.enqueue(new MockResponse().setBody(ACCESS_HEADER + SERVICE + ACCESS_FOOTER));
TokenIdAndPublicURL result = client.passwordAuth(server.getUrl("/").toURI(), "u", "p");
assertThat(result.tokenId).isEqualTo("1bcd122d87494f5ab39a185b9ec5ff73");
assertNull(result.publicURL);
}
@Test
public void noServices() throws Exception {
server.enqueue(new MockResponse().setBody(ACCESS_HEADER + SERVICE + ACCESS_FOOTER));
TokenIdAndPublicURL result = client.passwordAuth(server.getUrl("/").toURI(), "u", "p");
assertThat(result.tokenId).isEqualTo("1bcd122d87494f5ab39a185b9ec5ff73");
assertNull(result.publicURL);
}
@Test
public void noToken() throws Exception {
server.enqueue(new MockResponse().setBody("{\n"
+ " \"access\": {\n"
+ " \"serviceCatalog\": [{\n"
+ ACCESS_FOOTER));
TokenIdAndPublicURL result = client.passwordAuth(server.getUrl("/").toURI(), "u", "p");
assertNull(result);
}
static final String TOKEN = " \"token\": {\n"
+ " \"id\": \"1bcd122d87494f5ab39a185b9ec5ff73\",\n"
+ " \"expires\": \"2013-07-01T10:13:55.109-05:00\",\n"
+ " \"tenant\": {\n"
+ " \"id\": \"1234\",\n"
+ " \"name\": \"1234\"\n"
+ " }\n"
+ " },\n";
static final String ACCESS_HEADER = "{\n"
+ " \"access\": {\n"
+ TOKEN
+ " \"serviceCatalog\": [{\n";
static final String SERVICE = " }, {\n"
+ " \"name\": \"cloudMonitoring\",\n"
+ " \"endpoints\": [{\n"
+ " \"tenantId\": \"1234\",\n"
+ " \"publicURL\": \"https:\\/\\/monitoring.api.rackspacecloud.com\\/v1.0\\/1234\"\n"
+ " }],\n"
+ " \"type\": \"rax:monitor\"\n";
static final String ACCESS_FOOTER = " }]\n"
+ " }\n"
+ "}";
}
| 156 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSReadOnlyLiveTest.java | package denominator.clouddns;
import denominator.Live.UseTestGraph;
import denominator.ReadOnlyLiveTest;
@UseTestGraph(CloudDNSTestGraph.class)
public class CloudDNSReadOnlyLiveTest extends ReadOnlyLiveTest {
}
| 157 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSCheckConnectionLiveTest.java | package denominator.clouddns;
import denominator.CheckConnectionLiveTest;
import denominator.Live.UseTestGraph;
@UseTestGraph(CloudDNSTestGraph.class)
public class CloudDNSCheckConnectionLiveTest extends CheckConnectionLiveTest {
}
| 158 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSConnection.java | package denominator.clouddns;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
import denominator.DNSApiManager;
import denominator.Denominator;
import feign.Logger;
import static denominator.CredentialsConfiguration.credentials;
import static feign.Util.emptyToNull;
import static java.lang.System.getProperty;
public class CloudDNSConnection {
final DNSApiManager manager;
final String mutableZone;
CloudDNSConnection() {
String username = emptyToNull(getProperty("clouddns.username"));
String apiKey = emptyToNull(getProperty("clouddns.apiKey"));
if (username != null && apiKey != null) {
manager = create(username, apiKey);
} else {
manager = null;
}
mutableZone = emptyToNull(getProperty("clouddns.zone"));
}
static DNSApiManager create(String username, String apiKey) {
CloudDNSProvider provider = new CloudDNSProvider(emptyToNull(getProperty("clouddns.url")));
return Denominator.create(provider, credentials(username, apiKey), new Overrides());
}
@Module(overrides = true, library = true)
static class Overrides {
@Provides
@Singleton
Logger.Level provideLevel() {
return Logger.Level.FULL;
}
@Provides
@Singleton
Logger provideLogger() {
return new Logger.JavaLogger().appendToFile("build/http-wire.log");
}
}
}
| 159 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/LimitsReadableMockTest.java | package denominator.clouddns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import denominator.DNSApiManager;
import static denominator.clouddns.RackspaceApisTest.limitsResponse;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class LimitsReadableMockTest {
@Rule
public final MockCloudDNSServer server = new MockCloudDNSServer();
@Test
public void implicitlyStartsSessionWhichIsReusedForLaterRequests() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody("{ \"domains\": [] }"));
server.enqueue(new MockResponse().setBody(limitsResponse));
server.enqueue(new MockResponse().setBody(limitsResponse));
DNSApiManager api = server.connect();
assertTrue(api.checkConnection());
assertTrue(api.checkConnection());
server.assertAuthRequest();
server.assertRequest().hasPath("/v1.0/123123/limits");
server.assertRequest().hasPath("/v1.0/123123/limits");
}
@Test
public void singleRequestOnFailure() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setResponseCode(401));
DNSApiManager api = server.connect();
assertFalse(api.checkConnection());
server.assertAuthRequest();
}
}
| 160 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSProviderTest.java | package denominator.clouddns;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import dagger.ObjectGraph;
import denominator.Credentials.MapCredentials;
import denominator.DNSApiManager;
import denominator.Provider;
import static denominator.CredentialsConfiguration.credentials;
import static denominator.Denominator.create;
import static denominator.Providers.list;
import static denominator.Providers.provide;
import static org.assertj.core.api.Assertions.assertThat;
public class CloudDNSProviderTest {
private static final Provider PROVIDER = new CloudDNSProvider();
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void testCloudDNSMetadata() {
assertThat(PROVIDER.name()).isEqualTo("clouddns");
assertThat(PROVIDER.supportsDuplicateZoneNames()).isFalse();
assertThat(PROVIDER.credentialTypeToParameterNames())
.containsEntry("password", Arrays.asList("username", "password"))
.containsEntry("apiKey", Arrays.asList("username", "apiKey"));
}
@Test
public void testCloudDNSRegistered() {
assertThat(list()).contains(PROVIDER);
}
@Test
public void testProviderWiresCloudDNSZoneApi() {
DNSApiManager manager = create(PROVIDER, credentials("username", "apiKey"));
assertThat(manager.api().zones()).isInstanceOf(CloudDNSZoneApi.class);
manager = create("clouddns", credentials("username", "apiKey"));
assertThat(manager.api().zones()).isInstanceOf(CloudDNSZoneApi.class);
Map<String, String> map = new LinkedHashMap<String, String>();
map.put("username", "U");
map.put("apiKey", "K");
manager = create("clouddns", credentials(MapCredentials.from(map)));
assertThat(manager.api().zones()).isInstanceOf(CloudDNSZoneApi.class);
}
@Test
public void testCredentialsRequired() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage(
"no credentials supplied. clouddns requires one of the following forms: when type is password: username,password; apiKey: username,apiKey");
create(PROVIDER).api().zones().iterator();
}
@Test
public void testViaDagger() {
DNSApiManager manager = ObjectGraph
.create(provide(new CloudDNSProvider()), new CloudDNSProvider.Module(),
credentials("username", "apiKey"))
.get(DNSApiManager.class);
assertThat(manager.api().zones()).isInstanceOf(CloudDNSZoneApi.class);
}
}
| 161 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSResourceRecordSetApiMockTest.java | package denominator.clouddns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import java.util.Iterator;
import denominator.ResourceRecordSetApi;
import denominator.model.ResourceRecordSet;
import denominator.model.rdata.AData;
import denominator.model.rdata.SOAData;
import static denominator.assertj.ModelAssertions.assertThat;
import static denominator.clouddns.RackspaceApisTest.domainId;
import static denominator.clouddns.RackspaceApisTest.soaResponse;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
public class CloudDNSResourceRecordSetApiMockTest {
@Rule
public final MockCloudDNSServer server = new MockCloudDNSServer();
String
records =
"{\"records\":[{\"name\":\"www.denominator.io\",\"id\":\"A-9872761\",\"type\":\"A\",\"data\":\"1.2.3.4\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-8703385\",\"type\":\"NS\",\"data\":\"dns1.stabletransit.com\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-8703386\",\"type\":\"NS\",\"data\":\"dns2.stabletransit.com\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"}],\"totalEntries\":3}";
String
recordsPage1 =
"{\"records\":[{\"name\":\"www.denominator.io\",\"id\":\"A-9872761\",\"type\":\"A\",\"data\":\"1.2.3.4\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-8703385\",\"type\":\"NS\",\"data\":\"dns1.stabletransit.com\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-8703386\",\"type\":\"NS\",\"data\":\"dns2.stabletransit.com\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"}],\"totalEntries\":3,\"links\":[{\"href\":\"URL/v1.0/123123/domains/1234/records?limit=3&offset=3\",\"rel\":\"next\"}]}";
String
recordsPage2 =
"{\"records\":[{\"name\":\"www.denominator.io\",\"id\":\"A-9872761\",\"type\":\"A\",\"data\":\"1.2.3.4\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-8703385\",\"type\":\"NS\",\"data\":\"dns1.stabletransit.com\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-8703386\",\"type\":\"NS\",\"data\":\"dns2.stabletransit.com\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"}],\"totalEntries\":3,\"links\":[{\"href\":\"URL/v1.0/123123/domains/1234/records?limit=3&offset=0\",\"rel\":\"previous\"}]}";
String
recordsByName =
"{\"records\":[{\"name\":\"www.denominator.io\",\"id\":\"A-9872761\",\"type\":\"A\",\"data\":\"1.2.3.4\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-8703385\",\"type\":\"NS\",\"data\":\"dns1.stabletransit.com\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-8703386\",\"type\":\"NS\",\"data\":\"dns2.stabletransit.com\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"}],\"totalEntries\":3}";
String
recordsByNameAndType =
"{\"records\":[{\"name\":\"www.denominator.io\",\"id\":\"A-9872761\",\"type\":\"A\",\"data\":\"1.2.3.4\",\"ttl\":600000,\"updated\":\"2013-04-13T14:42:00.000+0000\",\"created\":\"2013-04-13T14:42:00.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"A-9883329\",\"type\":\"A\",\"data\":\"5.6.7.8\",\"ttl\":600000,\"updated\":\"2013-04-16T22:09:09.000+0000\",\"created\":\"2013-04-16T22:09:09.000+0000\"}]}";
@Test
public void listWhenPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(records));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone(domainId + "");
Iterator<ResourceRecordSet<?>> records = api.iterator();
while (records.hasNext()) {
assertThat(records.next())
.hasName("www.denominator.io")
.hasTtl(600000);
}
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records");
}
@Test
public void listWhenAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setResponseCode(404).setBody(
"{\"message\":\"Not Found\",\"code\":404,\"details\":\"\"}"));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone(domainId + "");
assertFalse(api.iterator().hasNext());
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records");
}
@Test
public void listPagesWhenPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(recordsPage1.replace("URL", server.url())));
server.enqueue(new MockResponse().setBody(recordsPage2.replace("URL", server.url())));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone(domainId + "");
Iterator<ResourceRecordSet<?>> records = api.iterator();
while (records.hasNext()) {
assertThat(records.next())
.hasName("www.denominator.io")
.hasTtl(600000);
}
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records");
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records?limit=3&offset=3");
}
@Test
public void iterateByNameWhenPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(recordsByName));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone(domainId + "");
Iterator<ResourceRecordSet<?>> records = api.iterateByName("www.denominator.io");
while (records.hasNext()) {
assertThat(records.next())
.hasName("www.denominator.io")
.hasTtl(600000);
}
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records");
}
@Test
public void iterateByNameWhenAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setResponseCode(404).setBody(
"{\"message\":\"Not Found\",\"code\":404,\"details\":\"\"}"));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone(domainId + "");
assertFalse(api.iterateByName("www.denominator.io").hasNext());
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records");
}
@Test
public void getByNameAndTypeWhenPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(recordsByNameAndType));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone(domainId + "");
assertThat(api.getByNameAndType("www.denominator.io", "A"))
.hasName("www.denominator.io")
.hasType("A")
.hasTtl(600000)
.containsExactlyRecords(AData.create("1.2.3.4"), AData.create("5.6.7.8"));
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records?name=www.denominator.io&type=A");
}
@Test
public void getByNameAndType_SOA() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(soaResponse));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone(domainId + "");
assertThat(api.getByNameAndType("denominator.io", "SOA"))
.hasName("denominator.io")
.hasType("SOA")
.hasTtl(3601)
.containsExactlyRecords(SOAData.builder()
.mname("ns.rackspace.com")
.rname("nil@denominator.io")
.serial(1427817447)
.refresh(3601).retry(3601)
.expire(3601).minimum(3601).build());
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records?name=denominator.io&type=SOA");
}
@Test
public void getByNameAndTypeWhenAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setResponseCode(404).setBody(
"{\"message\":\"Not Found\",\"code\":404,\"details\":\"\"}"));
ResourceRecordSetApi api = server.connect().api().basicRecordSetsInZone(domainId + "");
assertNull(api.getByNameAndType("www.denominator.io", "A"));
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains/1234/records?name=www.denominator.io&type=A");
}
}
| 162 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/RackspaceApisTest.java | package denominator.clouddns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import java.net.URI;
import denominator.Credentials;
import denominator.Provider;
import denominator.clouddns.RackspaceApis.CloudDNS;
import denominator.clouddns.RackspaceApis.CloudIdentity;
import denominator.clouddns.RackspaceApis.Job;
import denominator.clouddns.RackspaceApis.TokenIdAndPublicURL;
import denominator.model.Zone;
import feign.Feign;
import static denominator.assertj.ModelAssertions.assertThat;
import static java.lang.String.format;
import static org.assertj.core.groups.Tuple.tuple;
public class RackspaceApisTest {
@Rule
public final MockCloudDNSServer server = new MockCloudDNSServer();
@Test
public void passwordAuth() throws Exception {
server.credentials("username", "password");
server.enqueueAuthResponse();
CloudDNSProvider.FeignModule module = new CloudDNSProvider.FeignModule();
CloudIdentity api = module.cloudIdentity(module.feign(module.logger(), module.logLevel()));
TokenIdAndPublicURL tokenIdAndPublicURL = api.passwordAuth(
URI.create(server.url()), "username", "password");
assertThat(tokenIdAndPublicURL.tokenId).isEqualTo(server.tokenId());
assertThat(tokenIdAndPublicURL.publicURL)
.isEqualTo(server.url() + "/v1.0/" + server.tenantId());
server.assertRequest()
.hasMethod("POST")
.hasPath("/tokens")
.hasBody(
"{\"auth\":{\"passwordCredentials\":{\"username\":\"username\",\"password\":\"password\"}}}");
}
@Test
public void limitsSuccess() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(limitsResponse));
assertThat(mockApi().limits()).isNotEmpty();
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/limits");
}
@Test
public void domainsPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(domainsResponse));
assertThat(mockApi().domains().get(0))
.hasName("denominator.io");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains");
}
/**
* Rackspace doesn't expose the ttl in domain list. A dummy TTL of zero is added as this result is
* never used directly.
*/
@Test
public void domainsByNamePresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(domainsResponse));
assertThat(mockApi().domainsByName("denominator.io")).containsExactly(
Zone.create("1234", "denominator.io", 0, "nil@denominator.io")
);
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains?name=denominator.io");
}
@Test
public void domainsAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody("{\"domains\":[]}"));
assertThat(mockApi().domains()).isEmpty();
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/domains");
}
@Test
public void recordsPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(recordsResponse));
assertThat(mockApi().records(domainId))
.extracting("id", "name", "type", "ttl", "priority", "data")
.containsExactly(
tuple("A-10465369", "www.denominator.io", "A", 300, null, "192.0.2.1"),
tuple("A-10465370", "www.denominator.io", "A", 300, null, "192.0.2.2"),
tuple("NS-9084762", "www.denominator.io", "NS", 300, null, "dns1.stabletransit.com"),
tuple("NS-9084763", "www.denominator.io", "NS", 300, null, "dns2.stabletransit.com")
);
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath(format("/v1.0/123123/domains/%s/records", domainId));
}
@Test
public void recordsAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody("{\"records\":[]}"));
assertThat(mockApi().records(domainId)).isEmpty();
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath(format("/v1.0/123123/domains/%s/records", domainId));
}
@Test
public void createMXRecord() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(mxRecordInitialResponse));
Job job = mockApi().createRecordWithPriority(domainId, "www.denominator.io", "MX",
1800, "mail.denominator.io", 10);
assertThat(job.id).isEqualTo("0ade2b3b-07e4-4e68-821a-fcce4f5406f3");
assertThat(job.status).isEqualTo("RUNNING");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("POST")
.hasPath(format("/v1.0/123123/domains/%s/records", domainId))
.hasBody(mxRecordCreateRequest);
}
@Test
public void runningRequest() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(mxRecordRunningResponse));
Job job = mockApi().getStatus("0ade2b3b-07e4-4e68-821a-fcce4f5406f3");
assertThat(job.id).isEqualTo("0ade2b3b-07e4-4e68-821a-fcce4f5406f3");
assertThat(job.status).isEqualTo("RUNNING");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/status/0ade2b3b-07e4-4e68-821a-fcce4f5406f3?showDetails=true");
}
@Test
public void completedRequest() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(mxRecordCompletedResponse));
Job job = mockApi().getStatus("0ade2b3b-07e4-4e68-821a-fcce4f5406f3");
assertThat(job.id).isEqualTo("0ade2b3b-07e4-4e68-821a-fcce4f5406f3");
assertThat(job.status).isEqualTo("COMPLETED");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("GET")
.hasPath("/v1.0/123123/status/0ade2b3b-07e4-4e68-821a-fcce4f5406f3?showDetails=true");
}
@Test
public void updateMXRecord() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(mxRecordUpdateInitialResponse));
Job job = mockApi().updateRecord(domainId, "MX-4582544", 600, "mail.denominator.io");
assertThat(job.id).isEqualTo("e32eace1-c44f-49af-8f74-768fa34469f4");
assertThat(job.status).isEqualTo("RUNNING");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("PUT")
.hasPath(format("/v1.0/123123/domains/%s/records/MX-4582544", domainId))
.hasBody(mxRecordUpdateRequest);
}
@Test
public void deleteRecord() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(mxRecordDeleteInitialResponse));
Job job = mockApi().deleteRecord(domainId, "MX-4582544");
assertThat(job.id).isEqualTo("da520d24-dd5b-4387-92be-2020a7f2b176");
assertThat(job.status).isEqualTo("RUNNING");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("DELETE")
.hasPath(format("/v1.0/123123/domains/%s/records/MX-4582544", domainId));
}
CloudDNS mockApi() {
CloudDNSProvider.FeignModule module = new CloudDNSProvider.FeignModule();
Feign feign = module.feign(module.logger(), module.logLevel());
CloudIdentity cloudIdentity = module.cloudIdentity(feign);
Provider provider = new CloudDNSProvider() {
@Override
public String url() {
return server.url();
}
};
javax.inject.Provider<Credentials> credentials = new javax.inject.Provider<Credentials>() {
@Override
public Credentials get() {
return server.credentials();
}
};
return feign.newInstance(
new CloudDNSTarget(provider,
new InvalidatableAuthProvider(provider, cloudIdentity, credentials)));
}
static String limitsResponse = "{\n"
+ " \"rates\" : {\n"
+ " \"rate\" : [ {\n"
+ " \"uri\" : \"*/status/*\",\n"
+ " \"limit\" : [ {\n"
+ " \"value\" : 5,\n"
+ " \"verb\" : \"GET\",\n"
+ " \"unit\" : \"SECOND\"\n"
+ " } ],\n"
+ " \"regex\" : \".*/v\\\\d+\\\\.\\\\d+/(\\\\d+/status).*\"\n"
+ " }, {\n"
+ " \"uri\" : \"*/domains*\",\n"
+ " \"limit\" : [ {\n"
+ " \"value\" : 100,\n"
+ " \"verb\" : \"GET\",\n"
+ " \"unit\" : \"MINUTE\"\n"
+ " }, {\n"
+ " \"value\" : 25,\n"
+ " \"verb\" : \"POST\",\n"
+ " \"unit\" : \"MINUTE\"\n"
+ " }, {\n"
+ " \"value\" : 50,\n"
+ " \"verb\" : \"PUT\",\n"
+ " \"unit\" : \"MINUTE\"\n"
+ " }, {\n"
+ " \"value\" : 50,\n"
+ " \"verb\" : \"DELETE\",\n"
+ " \"unit\" : \"MINUTE\"\n"
+ " } ],\n"
+ " \"regex\" : \".*/v\\\\d+\\\\.\\\\d+/(\\\\d+/domains).*\"\n"
+ " } ]\n"
+ " }\n"
+ "}";
static int domainId = 1234;
static String
domainsResponse =
"{\"domains\":[{\"name\":\"denominator.io\",\"id\":1234,\"accountId\":123123,\"emailAddress\":\"nil@denominator.io\",\"updated\":\"2013-09-02T19:46:56.000+0000\",\"created\":\"2013-09-02T19:45:51.000+0000\"}],\"totalEntries\":1}";
static String
soaResponse =
"{\"records\":[{\"name\":\"denominator.io\",\"id\":\"SOA-4612221\",\"type\":\"SOA\",\"data\":\"ns.rackspace.com nil@denominator.io 1427817447\",\"ttl\":3601}]}";
// NOTE records are allowed to be out of order by type
static String
recordsResponse =
"{\"records\":[{\"name\":\"www.denominator.io\",\"id\":\"A-10465369\",\"type\":\"A\",\"data\":\"192.0.2.1\",\"ttl\":300,\"updated\":\"2013-09-02T20:51:55.000+0000\",\"created\":\"2013-09-02T20:51:55.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"A-10465370\",\"type\":\"A\",\"data\":\"192.0.2.2\",\"ttl\":300,\"updated\":\"2013-09-02T20:52:07.000+0000\",\"created\":\"2013-09-02T20:52:07.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-9084762\",\"type\":\"NS\",\"data\":\"dns1.stabletransit.com\",\"ttl\":300,\"updated\":\"2013-09-02T20:51:12.000+0000\",\"created\":\"2013-09-02T20:51:12.000+0000\"},{\"name\":\"www.denominator.io\",\"id\":\"NS-9084763\",\"type\":\"NS\",\"data\":\"dns2.stabletransit.com\",\"ttl\":300,\"updated\":\"2013-09-02T20:51:12.000+0000\",\"created\":\"2013-09-02T20:51:12.000+0000\"}],\"totalEntries\":4}";
static String
mxRecordCreateRequest =
"{\"records\":[{\"name\":\"www.denominator.io\",\"type\":\"MX\",\"ttl\":\"1800\",\"data\":\"mail.denominator.io\",\"priority\":\"10\"}]}";
static String
mxRecordInitialResponse =
"{\"request\":\"{\\\"records\\\":[{\\\"name\\\":\\\"www.denominator.io\\\",\\\"type\\\":\\\"MX\\\",\\\"ttl\\\":\\\"1800\\\",\\\"data\\\":\\\"mail.denominator.io\\\",\\\"priority\\\":\\\"10\\\"}]}\",\"status\":\"RUNNING\",\"verb\":\"POST\",\"jobId\":\"0ade2b3b-07e4-4e68-821a-fcce4f5406f3\",\"callbackUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/status/0ade2b3b-07e4-4e68-821a-fcce4f5406f3\",\"requestUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/domains/3854989/records\"}";
static String
mxRecordRunningResponse =
"{\"request\":\"{\\\"records\\\":[{\\\"name\\\":\\\"www.denominator.io\\\",\\\"type\\\":\\\"MX\\\",\\\"ttl\\\":\\\"1800\\\",\\\"data\\\":\\\"mail.denominator.io\\\",\\\"priority\\\":\\\"10\\\"}]}\",\"status\":\"RUNNING\",\"verb\":\"POST\",\"jobId\":\"0ade2b3b-07e4-4e68-821a-fcce4f5406f3\",\"callbackUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/status/0ade2b3b-07e4-4e68-821a-fcce4f5406f3\",\"requestUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/domains/3854989/records\"}";
static String
mxRecordCompletedResponse =
"{\"request\":\"{\\\"records\\\":[{\\\"name\\\":\\\"www.denominator.io\\\",\\\"type\\\":\\\"MX\\\",\\\"ttl\\\":\\\"1800\\\",\\\"data\\\":\\\"mail.denominator.io\\\",\\\"priority\\\":\\\"10\\\"}]}\",\"response\":{\"records\":[{\"name\":\"www.denominator.io\",\"id\":\"MX-4582544\",\"priority\":10,\"type\":\"MX\",\"data\":\"mail.denominator.io\",\"ttl\":1800,\"updated\":\"2013-09-02T21:10:03.000+0000\",\"created\":\"2013-09-02T21:10:03.000+0000\"}]},\"status\":\"COMPLETED\",\"verb\":\"POST\",\"jobId\":\"0ade2b3b-07e4-4e68-821a-fcce4f5406f3\",\"callbackUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/status/0ade2b3b-07e4-4e68-821a-fcce4f5406f3\",\"requestUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/domains/3854989/records\"}";
static String mxRecordUpdateRequest = "{\"ttl\":\"600\",\"data\":\"mail.denominator.io\"}";
static String
mxRecordUpdateInitialResponse =
"{\"request\":\"{\\\"ttl\\\":\\\"600\\\",\\\"data\\\":\\\"mail.denominator.io\\\"}\",\"status\":\"RUNNING\",\"verb\":\"PUT\",\"jobId\":\"e32eace1-c44f-49af-8f74-768fa34469f4\",\"callbackUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/status/e32eace1-c44f-49af-8f74-768fa34469f4\",\"requestUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/domains/3854989/records/MX-4582544\"}";
static String
mxRecordDeleteInitialResponse =
"{\"status\":\"RUNNING\",\"verb\":\"DELETE\",\"jobId\":\"da520d24-dd5b-4387-92be-2020a7f2b176\",\"callbackUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/status/da520d24-dd5b-4387-92be-2020a7f2b176\",\"requestUrl\":\"https://dns.api.rackspacecloud.com/v1.0/123123/domains/3854989/records/MX-4582544\"}";
}
| 163 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSZoneApiMockTest.java | package denominator.clouddns;
import com.squareup.okhttp.mockwebserver.MockResponse;
import org.junit.Rule;
import org.junit.Test;
import denominator.ZoneApi;
import denominator.model.Zone;
import static denominator.assertj.ModelAssertions.assertThat;
import static denominator.clouddns.RackspaceApisTest.domainsResponse;
import static denominator.clouddns.RackspaceApisTest.soaResponse;
public class CloudDNSZoneApiMockTest {
@Rule
public final MockCloudDNSServer server = new MockCloudDNSServer();
@Test
public void iteratorWhenPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(domainsResponse));
server.enqueue(new MockResponse().setBody(soaResponse));
ZoneApi api = server.connect().api().zones();
assertThat(api.iterator()).containsExactly(
Zone.create("1234", "denominator.io", 3601, "nil@denominator.io")
);
server.assertAuthRequest();
server.assertRequest().hasPath("/v1.0/123123/domains");
server.assertRequest()
.hasPath("/v1.0/123123/domains/1234/records?name=denominator.io&type=SOA");
}
@Test
public void iteratorWhenAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody("{ \"domains\": [] }"));
ZoneApi api = server.connect().api().zones();
assertThat(api.iterator()).isEmpty();
server.assertAuthRequest();
server.assertRequest().hasPath("/v1.0/123123/domains");
}
@Test
public void iteratorByNameWhenPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody(domainsResponse));
server.enqueue(new MockResponse().setBody(soaResponse));
ZoneApi api = server.connect().api().zones();
assertThat(api.iterateByName("denominator.io")).containsExactly(
Zone.create("1234", "denominator.io", 3601, "nil@denominator.io")
);
server.assertAuthRequest();
server.assertRequest().hasPath("/v1.0/123123/domains?name=denominator.io");
server.assertRequest()
.hasPath("/v1.0/123123/domains/1234/records?name=denominator.io&type=SOA");
}
@Test
public void iteratorByNameWhenAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(new MockResponse().setBody("{\"domains\":[],\"totalEntries\":0}"));
ZoneApi api = server.connect().api().zones();
assertThat(api.iterateByName("denominator.io")).isEmpty();
server.assertAuthRequest();
server.assertRequest().hasPath("/v1.0/123123/domains?name=denominator.io");
}
@Test
public void putWhenAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(creating);
server.enqueue(created);
ZoneApi api = server.connect().api().zones();
Zone zone = Zone.create(null, "denominator.io", 3601, "nil@denominator.io");
assertThat(api.put(zone)).isEqualTo("1234");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("POST")
.hasPath("/v1.0/123123/domains")
.hasBody(
"{\"domains\":[{\"name\":\"denominator.io\",\"emailAddress\":\"nil@denominator.io\",\"ttl\":3601}]}");
server.assertRequest()
.hasPath("/v1.0/123123/status/JOB_ID?showDetails=true");
}
@Test
public void putWhenPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(creating);
server.enqueue(domainAlreadyExists);
server.enqueue(new MockResponse().setBody(domainsResponse));
server.enqueue(updating);
server.enqueue(updated);
ZoneApi api = server.connect().api().zones();
Zone zone = Zone.create(null, "denominator.io", 3601, "nil@denominator.io");
assertThat(api.put(zone)).isEqualTo("1234");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("POST")
.hasPath("/v1.0/123123/domains")
.hasBody(
"{\"domains\":[{\"name\":\"denominator.io\",\"emailAddress\":\"nil@denominator.io\",\"ttl\":3601}]}");
server.assertRequest()
.hasPath("/v1.0/123123/status/JOB_ID?showDetails=true");
server.assertRequest().hasPath("/v1.0/123123/domains?name=denominator.io");
server.assertRequest()
.hasMethod("PUT")
.hasPath("/v1.0/123123/domains")
.hasBody(
"{\"domains\":[{\"id\":\"1234\",\"emailAddress\":\"nil@denominator.io\",\"ttl\":3601}]}");
server.assertRequest()
.hasPath("/v1.0/123123/status/JOB_ID?showDetails=true");
}
@Test
public void putWhenPresent_withId() throws Exception {
server.enqueueAuthResponse();
server.enqueue(updating);
server.enqueue(updated);
ZoneApi api = server.connect().api().zones();
Zone zone = Zone.create("1234", "denominator.io", 3601, "nil@denominator.io");
assertThat(api.put(zone)).isEqualTo("1234");
server.assertAuthRequest();
server.assertRequest()
.hasMethod("PUT")
.hasPath("/v1.0/123123/domains")
.hasBody(
"{\"domains\":[{\"id\":\"1234\",\"emailAddress\":\"nil@denominator.io\",\"ttl\":3601}]}");
server.assertRequest()
.hasPath("/v1.0/123123/status/JOB_ID?showDetails=true");
}
@Test
public void deleteWhenPresent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(deleting);
server.enqueue(deleted);
ZoneApi api = server.connect().api().zones();
api.delete("1234");
server.assertAuthRequest();
server.assertRequest().hasMethod("DELETE").hasPath("/v1.0/123123/domains/1234");
server.assertRequest().hasPath("/v1.0/123123/status/JOB_ID?showDetails=true");
}
@Test
public void deleteWhenAbsent() throws Exception {
server.enqueueAuthResponse();
server.enqueue(deleting);
server.enqueue(objectNotFound);
ZoneApi api = server.connect().api().zones();
api.delete("1234");
server.assertAuthRequest();
server.assertRequest().hasMethod("DELETE").hasPath("/v1.0/123123/domains/1234");
server.assertRequest().hasPath("/v1.0/123123/status/JOB_ID?showDetails=true");
}
private MockResponse creating = new MockResponse().setBody("{\n"
+ " \"status\": \"RUNNING\",\n"
+ " \"request\": \"{\\\"domains\\\":[{\\\"name\\\":\\\"denominator.io\\\",\\\"emailAddress\\\":\\\"test@denominator.io\\\",\\\"ttl\\\":3601}]}\",\n"
+ " \"verb\": \"POST\",\n"
+ " \"jobId\": \"JOB_ID\",\n"
+ " \"callbackUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/status/JOB_ID\",\n"
+ " \"requestUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/domains\"\n"
+ "}");
private MockResponse created = new MockResponse().setBody("{\n"
+ " \"status\": \"COMPLETED\",\n"
+ " \"request\": \"{\\\"domains\\\":[{\\\"name\\\":\\\"denominator.io\\\",\\\"emailAddress\\\":\\\"test@denominator.io\\\",\\\"ttl\\\":3601}]}\",\n"
+ " \"response\": {\n"
+ " \"domains\": [\n"
+ " {\n"
+ " \"name\": \"denominator.io\",\n"
+ " \"id\": 1234,\n"
+ " \"accountId\": 829000,\n"
+ " \"ttl\": 3601,\n"
+ " \"nameservers\": [\n"
+ " {\n"
+ " \"name\": \"dns1.stabletransit.com\"\n"
+ " },\n"
+ " {\n"
+ " \"name\": \"dns2.stabletransit.com\"\n"
+ " }\n"
+ " ],\n"
+ " \"emailAddress\": \"test@denominator.io\",\n"
+ " \"updated\": \"2015-04-04T14:58:39.000+0000\",\n"
+ " \"created\": \"2015-04-04T14:58:39.000+0000\"\n"
+ " }\n"
+ " ]\n"
+ " },\n"
+ " \"verb\": \"POST\",\n"
+ " \"jobId\": \"JOB_ID\",\n"
+ " \"callbackUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/status/JOB_ID\",\n"
+ " \"requestUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/domains\"\n"
+ "}");
private MockResponse domainAlreadyExists = new MockResponse().setBody("{\n"
+ " \"status\": \"ERROR\",\n"
+ " \"request\": \"{\\\"domains\\\":[{\\\"name\\\":\\\"denominator.io\\\",\\\"emailAddress\\\":\\\"nil@denominator.io\\\",\\\"ttl\\\":200000}]}\",\n"
+ " \"error\": {\n"
+ " \"message\": \"Conflict\",\n"
+ " \"code\": 409,\n"
+ " \"details\": \"Domain already exists\"\n"
+ " },\n"
+ " \"verb\": \"POST\",\n"
+ " \"jobId\": \"JOB_ID\",\n"
+ " \"callbackUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/status/JOB_ID\",\n"
+ " \"requestUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/domains\"\n"
+ "}");
private MockResponse updating = new MockResponse().setBody("{\n"
+ " \"status\": \"RUNNING\",\n"
+ " \"request\": \"{\\\"domains\\\":[{\\\"id\\\":\\\"4617747\\\",\\\"emailAddress\\\":\\\"test@denominator.io\\\",\\\"ttl\\\":3601}]}\",\n"
+ " \"verb\": \"PUT\",\n"
+ " \"jobId\": \"JOB_ID\",\n"
+ " \"callbackUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/status/JOB_ID\",\n"
+ " \"requestUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/domains\"\n"
+ "}");
private MockResponse updated = new MockResponse().setBody("{\n"
+ " \"status\": \"COMPLETED\",\n"
+ " \"request\": \"{\\\"domains\\\":[{\\\"id\\\":\\\"4617747\\\",\\\"emailAddress\\\":\\\"test@denominator.io\\\",\\\"ttl\\\":3601}]}\",\n"
+ " \"verb\": \"PUT\",\n"
+ " \"jobId\": \"JOB_ID\",\n"
+ " \"callbackUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/status/JOB_ID\",\n"
+ " \"requestUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/domains\"\n"
+ "}");
private MockResponse deleting = new MockResponse().setBody("{\n"
+ " \"status\": \"RUNNING\",\n"
+ " \"verb\": \"DELETE\",\n"
+ " \"jobId\": \"JOB_ID\",\n"
+ " \"callbackUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/status/JOB_ID\",\n"
+ " \"requestUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/domains/1234\"\n"
+ "}");
private MockResponse deleted = new MockResponse().setBody("{\n"
+ " \"status\": \"COMPLETED\",\n"
+ " \"verb\": \"DELETE\",\n"
+ " \"jobId\": \"JOB_ID\",\n"
+ " \"callbackUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/status/JOB_ID\",\n"
+ " \"requestUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/domains/1234\"\n"
+ "}");
private MockResponse objectNotFound = new MockResponse().setBody("{\n"
+ " \"status\": \"ERROR\",\n"
+ " \"error\": {\n"
+ " \"failedItems\": {\n"
+ " \"faults\": [\n"
+ " {\n"
+ " \"message\": \"Service Unavailable\",\n"
+ " \"code\": 503,\n"
+ " \"details\": \"com.rackspace.cloud.dns.exceptions.ObjectNotFoundException: ; Domain ID: 1234\"\n"
+ " }\n"
+ " ]\n"
+ " },\n"
+ " \"message\": \"One or more items could not be deleted.\",\n"
+ " \"code\": 500,\n"
+ " \"details\": \"See errors list for details.\"\n"
+ " },\n"
+ " \"verb\": \"DELETE\",\n"
+ " \"jobId\": \"JOB_ID\",\n"
+ " \"callbackUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/status/JOB_ID\",\n"
+ " \"requestUrl\": \"https://dns.api.rackspacecloud.com/v1.0/829000/domains/1234\"\n"
+ "}");
}
| 164 |
0 | Create_ds/denominator/clouddns/src/test/java/denominator | Create_ds/denominator/clouddns/src/test/java/denominator/clouddns/CloudDNSWriteCommandsLiveTest.java | package denominator.clouddns;
import denominator.Live.UseTestGraph;
import denominator.WriteCommandsLiveTest;
@UseTestGraph(CloudDNSTestGraph.class)
public class CloudDNSWriteCommandsLiveTest extends WriteCommandsLiveTest {
}
| 165 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/RackspaceApis.java | package denominator.clouddns;
import java.net.URI;
import java.util.ArrayList;
import java.util.Map;
import denominator.model.Zone;
import feign.Body;
import feign.FeignException;
import feign.Headers;
import feign.Param;
import feign.RequestLine;
class RackspaceApis {
static <X> ListWithNext<X> emptyOn404(Pager<X> pagingFunction, URI nullOrNext) {
try {
return pagingFunction.apply(nullOrNext);
} catch (FeignException e) {
if (e.getMessage().indexOf("status 404") != -1) {
return new ListWithNext<X>();
}
throw e;
}
}
@Headers("Content-Type: application/json")
interface CloudIdentity {
@RequestLine("POST /tokens")
@Body("%7B\"auth\":%7B\"RAX-KSKEY:apiKeyCredentials\":%7B\"username\":\"{username}\",\"apiKey\":\"{apiKey}\"%7D%7D%7D")
TokenIdAndPublicURL apiKeyAuth(URI endpoint, @Param("username") String username,
@Param("apiKey") String apiKey);
@RequestLine("POST /tokens")
@Body("%7B\"auth\":%7B\"passwordCredentials\":%7B\"username\":\"{username}\",\"password\":\"{password}\"%7D%7D%7D")
TokenIdAndPublicURL passwordAuth(URI endpoint, @Param("username") String username,
@Param("password") String password);
}
interface CloudDNS {
@RequestLine("GET /limits")
Map<String, Object> limits();
@RequestLine("GET /status/{jobId}?showDetails=true")
Job getStatus(@Param("jobId") String jobId);
@RequestLine("POST /domains")
@Body("%7B\"domains\":[%7B\"name\":\"{name}\",\"emailAddress\":\"{email}\",\"ttl\":{ttl}%7D]%7D")
@Headers("Content-Type: application/json")
Job createDomain(@Param("name") String name, @Param("email") String email,
@Param("ttl") int ttl);
@RequestLine("PUT /domains")
@Body("%7B\"domains\":[%7B\"id\":\"{id}\",\"emailAddress\":\"{email}\",\"ttl\":{ttl}%7D]%7D")
@Headers("Content-Type: application/json")
Job updateDomain(@Param("id") String id, @Param("email") String email, @Param("ttl") int ttl);
@RequestLine("DELETE /domains/{id}")
Job deleteDomain(@Param("id") String id);
/**
* Note this doesn't make sense to return anything except one or none, as duplicate domains
* aren't permitted in the create api.
*/
@RequestLine("GET /domains?name={name}")
ListWithNext<Zone> domainsByName(@Param("name") String name);
@RequestLine("GET")
ListWithNext<Zone> domains(URI href);
@RequestLine("GET /domains")
ListWithNext<Zone> domains();
@RequestLine("GET")
ListWithNext<Record> records(URI href);
@RequestLine("GET /domains/{domainId}/records")
ListWithNext<Record> records(@Param("domainId") int id);
@RequestLine("GET /domains/{domainId}/records?name={name}&type={type}")
ListWithNext<Record> recordsByNameAndType(@Param("domainId") int id,
@Param("name") String nameFilter,
@Param("type") String typeFilter);
@RequestLine("POST /domains/{domainId}/records")
@Body("%7B\"records\":[%7B\"name\":\"{name}\",\"type\":\"{type}\",\"ttl\":\"{ttl}\",\"data\":\"{data}\"%7D]%7D")
@Headers("Content-Type: application/json")
Job createRecord(@Param("domainId") int id, @Param("name") String name,
@Param("type") String type, @Param("ttl") int ttl, @Param("data") String data);
@RequestLine("POST /domains/{domainId}/records")
@Body("%7B\"records\":[%7B\"name\":\"{name}\",\"type\":\"{type}\",\"ttl\":\"{ttl}\",\"data\":\"{data}\",\"priority\":\"{priority}\"%7D]%7D")
@Headers("Content-Type: application/json")
Job createRecordWithPriority(@Param("domainId") int id, @Param("name") String name,
@Param("type") String type, @Param("ttl") int ttl,
@Param("data") String data, @Param("priority") int priority);
@RequestLine("PUT /domains/{domainId}/records/{recordId}")
@Body("%7B\"ttl\":\"{ttl}\",\"data\":\"{data}\"%7D")
@Headers("Content-Type: application/json")
Job updateRecord(@Param("domainId") int domainId, @Param("recordId") String recordId,
@Param("ttl") int ttl, @Param("data") String data);
@RequestLine("DELETE /domains/{domainId}/records/{recordId}")
Job deleteRecord(@Param("domainId") int domainId,
@Param("recordId") String recordId);
}
interface Pager<X> {
ListWithNext<X> apply(URI nullOrNext);
}
static class TokenIdAndPublicURL {
String tokenId;
String publicURL;
}
static class Job {
String id;
String status;
String errorDetails;
String resultId;
}
static class Record {
String id;
String name;
String type;
Integer ttl;
Integer priority;
private String data;
public String data() {
if ("AAAA".equals(type)) {
return data.toUpperCase();
}
return data;
}
public void data(String data) {
this.data = data;
}
// toString ordering
@Override
public String toString() {
return new StringBuilder(name).append(type).append(ttl).append(data).append(priority)
.toString();
}
}
static class ListWithNext<X> extends ArrayList<X> {
private static final long serialVersionUID = 1L;
URI next;
}
}
| 166 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/CloudDNSFunctions.java | package denominator.clouddns;
import java.util.List;
import java.util.Map;
import denominator.clouddns.RackspaceApis.CloudDNS;
import denominator.clouddns.RackspaceApis.Job;
import denominator.clouddns.RackspaceApis.Record;
import denominator.common.Util;
import denominator.model.rdata.MXData;
import denominator.model.rdata.SOAData;
import denominator.model.rdata.SRVData;
import denominator.model.rdata.TXTData;
import feign.RetryableException;
import feign.Retryer;
import static denominator.common.Util.split;
import static java.lang.String.format;
final class CloudDNSFunctions {
/**
* Returns the ID of the object created or null.
*/
static String awaitComplete(CloudDNS api, Job job) {
RetryableException retryableException = new RetryableException(
format("Job %s did not complete. Check your logs.", job.id), null);
Retryer retryer = new Retryer.Default(500, 1000, 30);
while (true) {
job = api.getStatus(job.id);
if ("COMPLETED".equals(job.status)) {
return job.resultId;
} else if ("ERROR".equals(job.status)) {
throw new IllegalStateException(
format("Job %s failed with error: %s", job.id, job.errorDetails));
}
retryer.continueOrPropagate(retryableException);
}
}
/**
* Special-cases priority field and the strange and incomplete SOA record.
*/
static Map<String, Object> toRDataMap(Record record) {
if ("MX".equals(record.type)) {
return MXData.create(record.priority, record.data());
} else if ("TXT".equals(record.type)) {
return TXTData.create(record.data());
} else if ("SRV".equals(record.type)) {
List<String> rdata = split(' ', record.data());
return SRVData.builder()
.priority(record.priority)
.weight(Integer.valueOf(rdata.get(0)))
.port(Integer.valueOf(rdata.get(1)))
.target(rdata.get(2)).build();
} else if ("SOA".equals(record.type)) {
List<String> threeParts = split(' ', record.data());
return SOAData.builder()
.mname(threeParts.get(0))
.rname(threeParts.get(1))
.serial(Integer.valueOf(threeParts.get(2)))
.refresh(record.ttl)
.retry(record.ttl)
.expire(record.ttl).minimum(record.ttl).build();
} else {
return Util.toMap(record.type, record.data());
}
}
private CloudDNSFunctions() {
}
}
| 167 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/KeystoneAccessAdapter.java | package denominator.clouddns;
import com.google.gson.JsonElement;
import com.google.gson.JsonIOException;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import denominator.clouddns.RackspaceApis.TokenIdAndPublicURL;
import static denominator.common.Preconditions.checkNotNull;
class KeystoneAccessAdapter extends TypeAdapter<TokenIdAndPublicURL> {
// rax:dns
private final String type;
KeystoneAccessAdapter(String type) {
this.type = checkNotNull(type, "type was null");
}
static boolean isNull(JsonElement element) {
return element == null || element.isJsonNull();
}
@Override
public TokenIdAndPublicURL read(JsonReader in) throws IOException {
JsonObject access;
try {
access = new JsonParser().parse(in).getAsJsonObject().get("access").getAsJsonObject();
} catch (JsonIOException e) {
if (e.getCause() != null && e.getCause() instanceof IOException) {
throw IOException.class.cast(e.getCause());
}
throw e;
}
JsonElement tokenField = access.get("token");
if (isNull(tokenField)) {
return null;
}
JsonElement idField = tokenField.getAsJsonObject().get("id");
if (isNull(idField)) {
return null;
}
TokenIdAndPublicURL tokenUrl = new TokenIdAndPublicURL();
tokenUrl.tokenId = idField.getAsString();
for (JsonElement s : access.get("serviceCatalog").getAsJsonArray()) {
JsonObject service = s.getAsJsonObject();
JsonElement typeField = service.get("type");
JsonElement endpointsField = service.get("endpoints");
if (!isNull(typeField) && !isNull(endpointsField) && type.equals(typeField.getAsString())) {
for (JsonElement e : endpointsField.getAsJsonArray()) {
JsonObject endpoint = e.getAsJsonObject();
tokenUrl.publicURL = endpoint.get("publicURL").getAsString();
}
}
}
return tokenUrl;
}
@Override
public String toString() {
return "KeystoneAccessAdapter(" + type + ")";
}
@Override
public void write(JsonWriter out, TokenIdAndPublicURL value) throws IOException {
throw new UnsupportedOperationException();
}
};
| 168 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/GroupByRecordNameAndTypeIterator.java | package denominator.clouddns;
import java.util.Iterator;
import java.util.Map;
import denominator.clouddns.RackspaceApis.Record;
import denominator.common.PeekingIterator;
import denominator.model.ResourceRecordSet;
import denominator.model.ResourceRecordSet.Builder;
import static denominator.clouddns.CloudDNSFunctions.toRDataMap;
import static denominator.common.Util.peekingIterator;
class GroupByRecordNameAndTypeIterator implements Iterator<ResourceRecordSet<?>> {
private final PeekingIterator<Record> peekingIterator;
public GroupByRecordNameAndTypeIterator(Iterator<Record> sortedIterator) {
this.peekingIterator = peekingIterator(sortedIterator);
}
private static boolean nameAndTypeEquals(Record actual, Record expected) {
return actual.name.equals(expected.name) && actual.type.equals(expected.type);
}
@Override
public boolean hasNext() {
return peekingIterator.hasNext();
}
@Override
public ResourceRecordSet<?> next() {
Record recordDetail = peekingIterator.next();
Builder<Map<String, Object>> builder = ResourceRecordSet.builder()
.name(recordDetail.name)
.type(recordDetail.type)
.ttl(recordDetail.ttl)
.add(toRDataMap(recordDetail));
while (hasNext()) {
Record next = peekingIterator.peek();
if (next == null) {
continue;
}
if (nameAndTypeEquals(next, recordDetail)) {
builder.add(toRDataMap(peekingIterator.next()));
} else {
break;
}
}
return builder.build();
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
| 169 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/InvalidatableAuthProvider.java | package denominator.clouddns;
import java.net.URI;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Provider;
import javax.inject.Singleton;
import denominator.Credentials;
import denominator.clouddns.RackspaceApis.CloudIdentity;
import denominator.clouddns.RackspaceApis.TokenIdAndPublicURL;
import static denominator.common.Preconditions.checkNotNull;
/**
* gets the current endpoint and authorization token from the identity service using password or api
* key auth.
*/
// similar to guava MemoizingSupplier
@Singleton
class InvalidatableAuthProvider implements Provider<TokenIdAndPublicURL> {
private final denominator.Provider provider;
private final CloudIdentity identityService;
private final Provider<Credentials> credentials;
transient volatile String lastKeystoneUrl;
transient volatile int lastCredentialsHashCode;
transient volatile boolean initialized;
// "value" does not need to be volatile; visibility piggy-backs
// on above
transient TokenIdAndPublicURL value;
@Inject
InvalidatableAuthProvider(denominator.Provider provider, CloudIdentity identityService,
Provider<Credentials> credentials) {
this.provider = provider;
this.identityService = identityService;
this.credentials = credentials;
// for toString
this.lastKeystoneUrl = provider.url();
}
public void invalidate() {
initialized = false;
}
@Override
public TokenIdAndPublicURL get() {
String currentUrl = provider.url();
Credentials currentCreds = credentials.get();
if (needsRefresh(currentUrl, currentCreds)) {
synchronized (this) {
if (needsRefresh(currentUrl, currentCreds)) {
lastCredentialsHashCode = currentCreds.hashCode();
lastKeystoneUrl = currentUrl;
TokenIdAndPublicURL t = auth(currentCreds);
value = t;
initialized = true;
return t;
}
}
}
return value;
}
private boolean needsRefresh(String currentUrl, Credentials currentCreds) {
return !initialized || currentCreds.hashCode() != lastCredentialsHashCode
|| !currentUrl.equals(lastKeystoneUrl);
}
private TokenIdAndPublicURL auth(Credentials currentCreds) {
URI url = URI.create(lastKeystoneUrl);
if (currentCreds instanceof Map) {
@SuppressWarnings("unchecked")
Map<String, Object> mapCreds = Map.class.cast(currentCreds);
String username = checkNotNull(mapCreds.get("username"), "username").toString();
if (mapCreds.containsKey("apiKey")) {
return identityService.apiKeyAuth(url, username, mapCreds.get("apiKey").toString());
}
String password = checkNotNull(mapCreds.get("password"), "password").toString();
return identityService.passwordAuth(url, username, password);
} else if (currentCreds instanceof List) {
@SuppressWarnings("unchecked")
List<Object> listCreds = List.class.cast(currentCreds);
return identityService
.apiKeyAuth(url, listCreds.get(0).toString(), listCreds.get(1).toString());
} else {
throw new IllegalArgumentException("Unsupported credential type: " + currentCreds);
}
}
@Override
public String toString() {
return "InvalidatableAuthSupplier(" + lastKeystoneUrl + ")";
}
}
| 170 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/LimitsReadable.java | package denominator.clouddns;
import javax.inject.Inject;
import denominator.CheckConnection;
import denominator.clouddns.RackspaceApis.CloudDNS;
class LimitsReadable implements CheckConnection {
private final CloudDNS api;
@Inject
LimitsReadable(CloudDNS api) {
this.api = api;
}
@Override
public boolean ok() {
try {
return api.limits() != null;
} catch (RuntimeException e) {
return false;
}
}
@Override
public String toString() {
return "LimitsReadable";
}
}
| 171 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/RackspaceAdapters.java | package denominator.clouddns;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
import java.util.Collections;
import java.util.Comparator;
import denominator.clouddns.RackspaceApis.Job;
import denominator.clouddns.RackspaceApis.ListWithNext;
import denominator.clouddns.RackspaceApis.Record;
import denominator.model.Zone;
class RackspaceAdapters {
private static final Comparator<Object> TO_STRING_COMPARATOR = new Comparator<Object>() {
@Override
public int compare(Object left, Object right) {
return left.toString().compareTo(right.toString());
}
};
@SuppressWarnings("unchecked")
private static <X> Comparator<X> toStringComparator() {
return Comparator.class.cast(TO_STRING_COMPARATOR);
}
static class JobAdapter extends TypeAdapter<Job> {
@Override
public void write(JsonWriter out, Job value) throws IOException {
// never need to write this object
}
@Override
public Job read(JsonReader reader) throws IOException {
Job job = new Job();
reader.beginObject();
while (reader.hasNext()) {
String key = reader.nextName();
if (key.equals("jobId")) {
job.id = reader.nextString();
// Hunt for an id in the response
// * response.*[0].id
} else if (key.equals("response")) {
reader.beginObject();
while (reader.hasNext()) {
reader.nextName(); // skip name
reader.beginArray();
reader.beginObject();
while (reader.hasNext()) {
key = reader.nextName();
if (key.equals("id")) {
job.resultId = reader.nextString();
} else {
reader.skipValue();
}
}
reader.endObject();
reader.endArray();
}
reader.endObject();
} else if (key.equals("status")) {
job.status = reader.nextString();
// There are two places to find a useful error message
// * error.failedItems.faults[0].details <- on delete
// * error.details <- on create
} else if (key.equals("error")) {
reader.beginObject();
while (reader.hasNext()) {
key = reader.nextName();
if (key.equals("failedItems")) {
reader.beginObject();
reader.nextName();
reader.beginArray();
reader.beginObject();
while (reader.hasNext()) {
key = reader.nextName();
if (key.equals("details")) {
job.errorDetails = reader.nextString();
} else {
reader.skipValue();
}
}
reader.endObject();
reader.endArray();
reader.endObject();
} else if (key.equals("details") && job.errorDetails == null) {
job.errorDetails = reader.nextString();
} else {
reader.skipValue();
}
}
reader.endObject();
} else {
reader.skipValue();
}
}
reader.endObject();
return job;
}
}
static class DomainListAdapter extends ListWithNextAdapter<Zone> {
@Override
protected String jsonKey() {
return "domains";
}
protected Zone build(JsonReader reader) throws IOException {
String name = null, id = null, email = null;
while (reader.hasNext()) {
String nextName = reader.nextName();
if (nextName.equals("id")) {
id = reader.nextString();
} else if (nextName.equals("name")) {
name = reader.nextString();
} else if (nextName.equals("emailAddress")) {
email = reader.nextString();
} else {
reader.skipValue();
}
}
return Zone.create(id, name, /* CloudDNS doesn't return ttl in the list api. */ 0, email);
}
}
static class RecordListAdapter extends ListWithNextAdapter<Record> {
@Override
protected String jsonKey() {
return "records";
}
protected Record build(JsonReader reader) throws IOException {
Record record = new Record();
while (reader.hasNext()) {
String key = reader.nextName();
if (key.equals("id")) {
record.id = reader.nextString();
} else if (key.equals("name")) {
record.name = reader.nextString();
} else if (key.equals("type")) {
record.type = reader.nextString();
} else if (key.equals("ttl")) {
record.ttl = reader.nextInt();
} else if (key.equals("data")) {
record.data(reader.nextString());
} else if (key.equals("priority")) {
record.priority = reader.nextInt();
} else {
reader.skipValue();
}
}
return record;
}
}
static abstract class ListWithNextAdapter<X> extends TypeAdapter<ListWithNext<X>> {
protected abstract String jsonKey();
protected abstract X build(JsonReader reader) throws IOException;
@Override
public ListWithNext<X> read(JsonReader reader) throws IOException {
ListWithNext<X> records = new ListWithNext<X>();
reader.beginObject();
while (reader.hasNext()) {
String nextName = reader.nextName();
if (jsonKey().equals(nextName)) {
reader.beginArray();
while (reader.hasNext()) {
reader.beginObject();
records.add(build(reader));
reader.endObject();
}
reader.endArray();
} else if ("links".equals(nextName)) {
reader.beginArray();
while (reader.hasNext()) {
String currentRel = null;
String currentHref = null;
reader.beginObject();
while (reader.hasNext()) {
String key = reader.nextName();
if ("rel".equals(key)) {
currentRel = reader.nextString();
} else if ("href".equals(key)) {
currentHref = reader.nextString();
} else {
reader.skipValue();
}
}
if ("next".equals(currentRel)) {
if (currentHref != null) {
records.next = URI.create(currentHref);
}
}
reader.endObject();
}
reader.endArray();
} else {
reader.skipValue();
}
}
reader.endObject();
Collections.sort(records, toStringComparator());
return records;
}
@Override
public void write(JsonWriter out, ListWithNext<X> value) throws IOException {
throw new UnsupportedOperationException();
}
}
}
| 172 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/CloudDNSProvider.java | package denominator.clouddns;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import javax.inject.Singleton;
import dagger.Provides;
import denominator.BasicProvider;
import denominator.CheckConnection;
import denominator.DNSApiManager;
import denominator.ResourceRecordSetApi;
import denominator.ZoneApi;
import denominator.clouddns.RackspaceAdapters.DomainListAdapter;
import denominator.clouddns.RackspaceAdapters.JobAdapter;
import denominator.clouddns.RackspaceAdapters.RecordListAdapter;
import denominator.clouddns.RackspaceApis.CloudDNS;
import denominator.clouddns.RackspaceApis.CloudIdentity;
import denominator.config.GeoUnsupported;
import denominator.config.NothingToClose;
import denominator.config.OnlyBasicResourceRecordSets;
import denominator.config.WeightedUnsupported;
import feign.Feign;
import feign.Logger;
import feign.Target.EmptyTarget;
import feign.gson.GsonDecoder;
import feign.gson.GsonEncoder;
public class CloudDNSProvider extends BasicProvider {
private final String url;
public CloudDNSProvider() {
this(null);
}
/**
* @param url if empty or null use default
*/
public CloudDNSProvider(String url) {
this.url = url == null || url.isEmpty() ? "https://identity.api.rackspacecloud.com/v2.0" : url;
}
@Override
public String url() {
return url;
}
// http://docs.rackspace.com/cdns/api/v1.0/cdns-devguide/content/supported_record_types.htm
// PTR records can only be created with a live Cloud Server
// SRV records fail to be found by name and type, a bug has been filed and SRV records may be supported later
@Override
public Set<String> basicRecordTypes() {
Set<String> types = new LinkedHashSet<String>();
types.addAll(Arrays.asList("A", "AAAA", "CNAME", "MX", "NS", "TXT"));
return types;
}
// TODO: verify when write support is added
@Override
public Map<String, Collection<String>> profileToRecordTypes() {
Map<String, Collection<String>>
profileToRecordTypes =
new LinkedHashMap<String, Collection<String>>();
profileToRecordTypes.put("roundRobin", basicRecordTypes());
return profileToRecordTypes;
}
@Override
public Map<String, Collection<String>> credentialTypeToParameterNames() {
Map<String, Collection<String>> options = new LinkedHashMap<String, Collection<String>>();
options.put("password", Arrays.asList("username", "password"));
options.put("apiKey", Arrays.asList("username", "apiKey"));
return options;
}
@dagger.Module(injects = DNSApiManager.class, complete = false, overrides = true, includes = {
NothingToClose.class, GeoUnsupported.class, WeightedUnsupported.class,
OnlyBasicResourceRecordSets.class,
FeignModule.class})
public static final class Module {
@Provides
CheckConnection checkConnection(LimitsReadable checkConnection) {
return checkConnection;
}
@Provides
@Singleton
ZoneApi provideZoneApi(CloudDNSZoneApi api) {
return api;
}
@Provides
@Singleton
ResourceRecordSetApi.Factory provideResourceRecordSetApiFactory(
CloudDNSResourceRecordSetApi.Factory api) {
return api;
}
}
@dagger.Module(injects = CloudDNSResourceRecordSetApi.Factory.class,
complete = false // doesn't bind Provider used by CloudDNSTarget
)
public static final class FeignModule {
@Provides
@Singleton
CloudDNS cloudDNS(Feign feign, CloudDNSTarget target) {
return feign.newInstance(target);
}
@Provides
@Singleton
CloudIdentity cloudIdentity(Feign feign) {
return feign.newInstance(EmptyTarget.create(CloudIdentity.class, "cloudidentity"));
}
@Provides
Logger logger() {
return new Logger.NoOpLogger();
}
@Provides
Logger.Level logLevel() {
return Logger.Level.NONE;
}
@Provides
@Singleton
Feign feign(Logger logger, Logger.Level logLevel) {
return Feign.builder()
.logger(logger)
.logLevel(logLevel)
.encoder(new GsonEncoder())
.decoder(new GsonDecoder(Arrays.asList(
new KeystoneAccessAdapter("rax:dns"),
new JobAdapter(),
new DomainListAdapter(),
new RecordListAdapter()))
)
.build();
}
}
}
| 173 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/CloudDNSZoneApi.java | package denominator.clouddns;
import java.util.Iterator;
import javax.inject.Inject;
import denominator.clouddns.RackspaceApis.CloudDNS;
import denominator.clouddns.RackspaceApis.ListWithNext;
import denominator.clouddns.RackspaceApis.Record;
import denominator.model.Zone;
import static denominator.clouddns.CloudDNSFunctions.awaitComplete;
import static denominator.common.Util.singletonIterator;
class CloudDNSZoneApi implements denominator.ZoneApi {
private final CloudDNS api;
@Inject
CloudDNSZoneApi(CloudDNS api) {
this.api = api;
}
@Override
public Iterator<Zone> iterator() {
return new ZipWithDomain(api.domains());
}
@Override
public Iterator<Zone> iterateByName(String name) {
ListWithNext<Zone> zones = api.domainsByName(name);
if (zones.isEmpty()) {
return singletonIterator(null);
}
return singletonIterator(zipWithSOA(zones.get(0)));
}
/**
* CloudDNS doesn't expose the domain's ttl in the list api.
*/
private Zone zipWithSOA(Zone next) {
Record soa = api.recordsByNameAndType(Integer.parseInt(next.id()), next.name(), "SOA").get(0);
return Zone.create(next.id(), next.name(), soa.ttl, next.email());
}
class ZipWithDomain implements Iterator<Zone> {
ListWithNext<Zone> list;
int i = 0;
int length;
ZipWithDomain(ListWithNext<Zone> list) {
this.list = list;
this.length = list.size();
}
@Override
public boolean hasNext() {
while (i == length && list.next != null) {
list = api.domains(list.next);
length = list.size();
i = 0;
}
return i < length;
}
@Override
public Zone next() {
return zipWithSOA(list.get(i++));
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
@Override
public String put(Zone zone) {
if (zone.id() != null) {
return updateZone(zone.id(), zone);
}
try {
return awaitComplete(api, api.createDomain(zone.name(), zone.email(), zone.ttl()));
} catch (IllegalStateException e) {
if (e.getMessage().indexOf("already exists") == -1) {
throw e;
}
String id = api.domainsByName(zone.name()).get(0).id();
return updateZone(id, zone);
}
}
private String updateZone(String id, Zone zone) {
awaitComplete(api, api.updateDomain(id, zone.email(), zone.ttl()));
return id;
}
@Override
public void delete(String id) {
try {
awaitComplete(api, api.deleteDomain(id));
} catch (IllegalStateException e) {
if (e.getMessage().indexOf("ObjectNotFoundException") == -1) {
throw e;
}
}
}
}
| 174 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/CloudDNSResourceRecordSetApi.java | package denominator.clouddns;
import java.net.URI;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.inject.Inject;
import denominator.ResourceRecordSetApi;
import denominator.clouddns.RackspaceApis.CloudDNS;
import denominator.clouddns.RackspaceApis.ListWithNext;
import denominator.clouddns.RackspaceApis.Pager;
import denominator.clouddns.RackspaceApis.Record;
import denominator.common.Util;
import denominator.model.ResourceRecordSet;
import static denominator.clouddns.CloudDNSFunctions.awaitComplete;
import static denominator.clouddns.CloudDNSFunctions.toRDataMap;
import static denominator.clouddns.RackspaceApis.emptyOn404;
import static denominator.common.Preconditions.checkArgument;
import static denominator.common.Preconditions.checkNotNull;
import static denominator.common.Util.filter;
import static denominator.common.Util.join;
import static denominator.common.Util.nextOrNull;
import static denominator.model.ResourceRecordSets.nameEqualTo;
class CloudDNSResourceRecordSetApi implements denominator.ResourceRecordSetApi {
private static final int DEFAULT_TTL = 300;
private final CloudDNS api;
private final int domainId;
CloudDNSResourceRecordSetApi(CloudDNS api, int domainId) {
this.api = api;
this.domainId = domainId;
}
@Override
public Iterator<ResourceRecordSet<?>> iterator() {
Pager<Record> recordPager = new Pager<Record>() {
public ListWithNext<Record> apply(URI nullOrNext) {
return nullOrNext == null ? api.records(domainId) : api.records(nullOrNext);
}
};
return new GroupByRecordNameAndTypeIterator(lazyIterateRecords(recordPager));
}
@Override
public Iterator<ResourceRecordSet<?>> iterateByName(String name) {
checkNotNull(name, "name was null");
return filter(iterator(), nameEqualTo(name));
}
@Override
public ResourceRecordSet<?> getByNameAndType(final String name, final String type) {
checkNotNull(name, "name was null");
checkNotNull(type, "type was null");
Pager<Record> recordPager = new Pager<Record>() {
public ListWithNext<Record> apply(URI nullOrNext) {
return nullOrNext == null ? api.recordsByNameAndType(domainId, name, type)
: api.records(nullOrNext);
}
};
return nextOrNull(new GroupByRecordNameAndTypeIterator(lazyIterateRecords(recordPager)));
}
@Override
public void put(ResourceRecordSet<?> rrset) {
checkNotNull(rrset, "rrset was null");
checkArgument(!rrset.records().isEmpty(), "rrset was empty %s", rrset);
List<Map<String, Object>>
recordsLeftToCreate =
new ArrayList<Map<String, Object>>(rrset.records());
for (Record record : api.recordsByNameAndType(domainId, rrset.name(), rrset.type())) {
Map<String, Object> rdata = toRDataMap(record);
if (recordsLeftToCreate.contains(rdata)) {
recordsLeftToCreate.remove(rdata);
if (rrset.ttl() != null) {
if (Util.equal(rrset.ttl(), record.ttl)) {
continue;
}
awaitComplete(api, api.updateRecord(domainId, record.id, rrset.ttl(), record.data()));
}
} else {
awaitComplete(api, api.deleteRecord(domainId, record.id));
}
}
int ttlToApply = rrset.ttl() != null ? rrset.ttl() : DEFAULT_TTL;
for (Map<String, Object> rdata : recordsLeftToCreate) {
Map<String, Object> mutableRData = new LinkedHashMap<String, Object>(rdata);
Integer priority = getPriority(mutableRData);
String data = join(' ', mutableRData.values().toArray());
if (priority == null) {
awaitComplete(api,
api.createRecord(domainId, rrset.name(), rrset.type(), ttlToApply, data));
} else {
awaitComplete(api, api.createRecordWithPriority(
domainId, rrset.name(), rrset.type(), ttlToApply, data, priority));
}
}
}
/**
* Has the side effect of removing the priority from the mutableRData.
*
* @return null or the priority, if it exists for a MX or SRV record
*/
private Integer getPriority(Map<String, Object> mutableRData) {
Integer priority = null;
if (mutableRData.containsKey("priority")) { // SRVData
priority = Integer.class.cast(mutableRData.remove("priority"));
} else if (mutableRData.containsKey("preference")) { // MXData
priority = Integer.class.cast(mutableRData.remove("preference"));
}
return priority;
}
@Override
public void deleteByNameAndType(String name, String type) {
checkNotNull(name, "name");
checkNotNull(type, "type");
for (Record record : api.recordsByNameAndType(domainId, name, type)) {
awaitComplete(api, api.deleteRecord(domainId, record.id));
}
}
Iterator<Record> lazyIterateRecords(final Pager<Record> recordPager) {
final ListWithNext<Record> first = emptyOn404(recordPager, null);
if (first.next == null) {
return first.iterator();
}
return new Iterator<Record>() {
Iterator<Record> current = first.iterator();
URI next = first.next;
@Override
public boolean hasNext() {
while (!current.hasNext() && next != null) {
ListWithNext<Record> nextPage = emptyOn404(recordPager, next);
current = nextPage.iterator();
next = nextPage.next;
}
return current.hasNext();
}
@Override
public Record next() {
return current.next();
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
static final class Factory implements denominator.ResourceRecordSetApi.Factory {
private final CloudDNS api;
@Inject
Factory(CloudDNS api) {
this.api = api;
}
@Override
public ResourceRecordSetApi create(String id) {
return new CloudDNSResourceRecordSetApi(api, Integer.parseInt(id));
}
}
}
| 175 |
0 | Create_ds/denominator/clouddns/src/main/java/denominator | Create_ds/denominator/clouddns/src/main/java/denominator/clouddns/CloudDNSTarget.java | package denominator.clouddns;
import javax.inject.Inject;
import denominator.Provider;
import denominator.clouddns.RackspaceApis.CloudDNS;
import denominator.clouddns.RackspaceApis.TokenIdAndPublicURL;
import feign.Request;
import feign.RequestTemplate;
import feign.Target;
class CloudDNSTarget implements Target<CloudDNS> {
private final Provider provider;
private final InvalidatableAuthProvider lazyUrlAndToken;
@Inject
CloudDNSTarget(Provider provider, InvalidatableAuthProvider lazyUrlAndToken) {
this.provider = provider;
this.lazyUrlAndToken = lazyUrlAndToken;
}
@Override
public Class<CloudDNS> type() {
return CloudDNS.class;
}
@Override
public String name() {
return provider.name();
}
@Override
public String url() {
return lazyUrlAndToken.get().publicURL;
}
@Override
public Request apply(RequestTemplate input) {
TokenIdAndPublicURL urlAndToken = lazyUrlAndToken.get();
if (input.url().indexOf("http") != 0) {
input.insert(0, urlAndToken.publicURL);
}
input.header("X-Auth-Token", urlAndToken.tokenId);
return input.request();
}
}
| 176 |
0 | Create_ds/denominator/example-android/src/main/java/denominator/example | Create_ds/denominator/example-android/src/main/java/denominator/example/android/DenominatorApplication.java | package denominator.example.android;
import android.app.Application;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import android.util.Log;
import android.widget.Toast;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.inject.Singleton;
import dagger.Module;
import dagger.ObjectGraph;
import dagger.Provides;
import denominator.Credentials;
import denominator.Provider;
import denominator.example.android.ui.PreferencesActivity;
import denominator.example.android.zone.ZoneListModule;
import denominator.ultradns.UltraDNSProvider;
import static android.widget.Toast.LENGTH_SHORT;
public class DenominatorApplication extends Application {
private static final String TAG = "Denominator:Application";
private ObjectGraph applicationGraph;
@Override
public void onCreate() {
Log.i(TAG, " creating");
super.onCreate();
long start = System.currentTimeMillis();
@Module(injects = DenominatorApplication.class, complete = false)
class ApplicationModule {
@Provides
@Singleton
Application application() {
return DenominatorApplication.this;
}
}
Object[] modulesForGraph = new Object[4];
modulesForGraph[0] = new DenominatorProvider();
modulesForGraph[1] = new CredentialsFromPreferencesModule();
modulesForGraph[2] = new ApplicationModule();
modulesForGraph[3] = new ZoneListModule();
applicationGraph = ObjectGraph.create(modulesForGraph);
long duration = System.currentTimeMillis() - start;
String durationMessage = getString(R.string.init_duration, duration);
Toast.makeText(this, durationMessage, LENGTH_SHORT).show();
Log.i(TAG, " created");
}
public ObjectGraph getApplicationGraph() {
return applicationGraph;
}
/**
* Here's where to change for a different provider
*/
@Module(includes = UltraDNSProvider.Module.class, complete = false)
static final class DenominatorProvider {
@Provides
@Singleton
public Provider provider() {
return new UltraDNSProvider();
}
}
@Module(
injects = {
PreferencesActivity.class
},
library = true,
complete = false
)
static class CredentialsFromPreferencesModule {
@Provides
Credentials credentials(Application context, Provider provider) {
PreferenceManager.getDefaultSharedPreferences(context);
if (provider.credentialTypeToParameterNames().isEmpty()) {
return Credentials.AnonymousCredentials.INSTANCE;
}
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
String credentialType = provider.credentialTypeToParameterNames().keySet().iterator().next();
Map<String, String> creds = new LinkedHashMap<String, String>();
for (String parameter : provider.credentialTypeToParameterNames().get(credentialType)) {
String value = sp.getString(parameter, null);
creds.put(parameter, value);
}
return Credentials.MapCredentials.from(creds);
}
}
}
| 177 |
0 | Create_ds/denominator/example-android/src/main/java/denominator/example/android | Create_ds/denominator/example-android/src/main/java/denominator/example/android/ui/PreferencesActivity.java | package denominator.example.android.ui;
import android.os.Bundle;
import android.preference.EditTextPreference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;
import javax.inject.Inject;
import denominator.Provider;
import denominator.example.android.DenominatorApplication;
public class PreferencesActivity extends PreferenceActivity {
@Inject
Provider provider;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
DenominatorApplication.class.cast(getApplication()).getApplicationGraph().inject(this);
// to support api level 9
this.setPreferenceScreen(createFromProvider());
}
private PreferenceScreen createFromProvider() {
PreferenceScreen root = getPreferenceManager().createPreferenceScreen(this);
if (provider.credentialTypeToParameterNames().isEmpty()) {
return root;
}
String credentialType = provider.credentialTypeToParameterNames().keySet().iterator().next();
root.setTitle(credentialType + " credentials for provider " + provider.name());
for (String parameter : provider.credentialTypeToParameterNames().get(credentialType)) {
EditTextPreference cred = new EditTextPreference(this);
cred.setKey(parameter);
cred.setTitle(parameter);
cred.setDialogTitle(parameter);
root.addPreference(cred);
}
return root;
}
}
| 178 |
0 | Create_ds/denominator/example-android/src/main/java/denominator/example/android | Create_ds/denominator/example-android/src/main/java/denominator/example/android/ui/HomeActivity.java | package denominator.example.android.ui;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import android.view.KeyEvent;
import android.widget.Toast;
import com.squareup.otto.Bus;
import com.squareup.otto.Subscribe;
import com.squareup.tape.TaskQueue;
import javax.inject.Inject;
import javax.inject.Singleton;
import dagger.ObjectGraph;
import dagger.Provides;
import denominator.Provider;
import denominator.example.android.DenominatorApplication;
import denominator.example.android.R;
import denominator.example.android.zone.ZoneList;
import static android.widget.Toast.LENGTH_LONG;
import static android.widget.Toast.LENGTH_SHORT;
public class HomeActivity extends FragmentActivity {
@Inject
Provider provider;
@Inject
ZoneList zoneList;
@Inject
TaskQueue<ZoneList> taskQueue;
@Inject
Bus bus;
private ObjectGraph activityGraph;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
DenominatorApplication application = DenominatorApplication.class.cast(getApplication());
// make a child graph that injects us and our fragments
@dagger.Module(injects = {
HomeActivity.class,
ZoneListFragment.class
}, complete = false)
class ActivityModule {
@Provides
@Singleton
Activity provideActivityContext() {
return HomeActivity.this;
}
}
activityGraph = application.getApplicationGraph().plus(new ActivityModule());
activityGraph.inject(this);
setTitle(getString(R.string.home_title, provider.name()));
if (savedInstanceState == null) {
getSupportFragmentManager().beginTransaction()
.add(android.R.id.content, inject(new ZoneListFragment()))
.commit();
}
}
// wire up preferences screen when menu button is pressed.
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_MENU) {
startActivity(new Intent(this, PreferencesActivity.class));
return true;
}
return super.onKeyDown(keyCode, event);
}
/**
* flash the response time of doing the list.
*/
@Subscribe
public void onZones(ZoneList.SuccessEvent event) {
String durationEvent = getString(R.string.list_duration, event.duration);
Toast.makeText(this, durationEvent, LENGTH_SHORT).show();
}
/**
* show any error messages posted to the bus.
*/
@Subscribe
public void onFailure(Throwable t) {
Toast.makeText(this, t.getMessage(), LENGTH_LONG).show();
}
@Override
public void onResume() {
super.onResume();
bus.register(this);
taskQueue.add(zoneList);
}
@Override
public void onPause() {
super.onPause();
bus.unregister(this);
}
@Override
protected void onDestroy() {
activityGraph = null;
super.onDestroy();
}
/**
* use this on {@link android.support.v4.app.Fragment#onActivityCreated} to restore injected
* fields.
*/
public <T> T inject(T toInject) {
return activityGraph.inject(toInject);
}
}
| 179 |
0 | Create_ds/denominator/example-android/src/main/java/denominator/example/android | Create_ds/denominator/example-android/src/main/java/denominator/example/android/ui/ZoneListFragment.java | package denominator.example.android.ui;
import android.app.Activity;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ScrollView;
import android.widget.TableLayout;
import android.widget.TableRow;
import android.widget.TextView;
import com.squareup.otto.Bus;
import com.squareup.otto.Subscribe;
import javax.inject.Inject;
import denominator.example.android.zone.ZoneList;
import denominator.model.Zone;
import static android.view.Gravity.CENTER;
public class ZoneListFragment extends Fragment {
@Inject
Activity activity;
@Inject
Bus bus;
TableLayout zones;
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
HomeActivity.class.cast(getActivity()).inject(this);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
zones = new TableLayout(getActivity());
zones.setGravity(CENTER);
ScrollView view = new ScrollView(getActivity());
view.addView(zones);
return view;
}
@Subscribe
public void onZones(ZoneList.SuccessEvent event) {
zones.removeAllViews();
while (event.zones.hasNext()) {
Zone zone = event.zones.next();
TableRow row = new TableRow(activity);
TextView name = new TextView(activity);
name.setText(zone.name());
row.addView(name);
if (zone.id() != null) {
TextView id = new TextView(activity);
id.setText(zone.id());
row.addView(id);
}
zones.addView(row);
}
}
@Override
public void onResume() {
super.onResume();
bus.register(this);
}
@Override
public void onPause() {
super.onPause();
bus.unregister(this);
}
}
| 180 |
0 | Create_ds/denominator/example-android/src/main/java/denominator/example/android | Create_ds/denominator/example-android/src/main/java/denominator/example/android/zone/ZoneList.java | package denominator.example.android.zone;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import com.squareup.tape.Task;
import java.util.Iterator;
import javax.inject.Inject;
import denominator.DNSApiManager;
import denominator.model.Zone;
public class ZoneList implements Task<ZoneList.Callback> {
private static final String TAG = "Denominator:ZoneList";
private static final Handler MAIN_THREAD = new Handler(Looper.getMainLooper());
private final DNSApiManager mgr;
@Inject
ZoneList(DNSApiManager mgr) {
this.mgr = mgr;
}
@Override
public void execute(final ZoneList.Callback callback) {
new Thread(new Runnable() {
@Override
public void run() {
Log.i(TAG, "Listing Zones in " + mgr.provider().name());
try {
long start = System.currentTimeMillis();
final Iterator<Zone> zones = mgr.api().zones().iterator();
final long duration = System.currentTimeMillis() - start;
Log.i(TAG, "success! " + mgr.provider().name());
MAIN_THREAD.post(new Runnable() {
@Override
public void run() {
callback.onSuccess(zones, duration);
}
});
} catch (final RuntimeException e) {
e.printStackTrace();
MAIN_THREAD.post(new Runnable() {
@Override
public void run() {
callback.onFailure(e);
}
});
}
}
}).start();
}
public interface Callback {
void onSuccess(Iterator<Zone> zones, long duration);
void onFailure(Throwable t);
}
public static class SuccessEvent {
public final Iterator<Zone> zones;
public final long duration;
SuccessEvent(Iterator<Zone> zones, long duration) {
this.zones = zones;
this.duration = duration;
}
}
}
| 181 |
0 | Create_ds/denominator/example-android/src/main/java/denominator/example/android | Create_ds/denominator/example-android/src/main/java/denominator/example/android/zone/ZoneListModule.java | package denominator.example.android.zone;
import com.squareup.otto.Bus;
import com.squareup.tape.InMemoryObjectQueue;
import com.squareup.tape.ObjectQueue;
import com.squareup.tape.TaskQueue;
import javax.inject.Singleton;
import dagger.Provides;
@dagger.Module(
injects = ZoneListTaskService.class,
complete = false // application
)
public class ZoneListModule {
@Provides
@Singleton
ObjectQueue<ZoneList> objectQueue() {
return new InMemoryObjectQueue<ZoneList>();
}
@Provides
@Singleton
TaskQueue<ZoneList> taskQueue(ZoneListQueue zlq) {
return zlq;
}
@Provides
@Singleton
Bus bus() {
return new Bus();
}
}
| 182 |
0 | Create_ds/denominator/example-android/src/main/java/denominator/example/android | Create_ds/denominator/example-android/src/main/java/denominator/example/android/zone/ZoneListQueue.java | package denominator.example.android.zone;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import com.squareup.otto.Bus;
import com.squareup.tape.ObjectQueue;
import javax.inject.Inject;
public class ZoneListQueue extends com.squareup.tape.TaskQueue<ZoneList> {
private final Context context;
private final Bus bus;
@Inject
ZoneListQueue(ObjectQueue<ZoneList> delegate, Application context, Bus bus) {
super(delegate);
this.context = context;
this.bus = bus;
bus.register(this);
if (size() > 0) {
startService();
}
}
private void startService() {
context.startService(new Intent(context, ZoneListTaskService.class));
}
@Override
public void add(ZoneList entry) {
super.add(entry);
startService();
}
}
| 183 |
0 | Create_ds/denominator/example-android/src/main/java/denominator/example/android | Create_ds/denominator/example-android/src/main/java/denominator/example/android/zone/ZoneListTaskService.java | package denominator.example.android.zone;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
import com.squareup.otto.Bus;
import com.squareup.tape.TaskQueue;
import java.util.Iterator;
import javax.inject.Inject;
import denominator.example.android.DenominatorApplication;
import denominator.example.android.zone.ZoneList.Callback;
import denominator.model.Zone;
/**
* This service guarantees that zone lists happen in the background and only once at a time.
*/
public class ZoneListTaskService extends Service implements Callback {
private static final String TAG = "Denominator:ZoneListTaskService";
@Inject
TaskQueue<ZoneList> taskQueue;
@Inject
Bus bus;
private boolean running;
@Override
public void onCreate() {
super.onCreate();
DenominatorApplication.class.cast(getApplication()).getApplicationGraph().inject(this);
Log.i(TAG, " starting");
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
executeNext();
return START_STICKY;
}
private void executeNext() {
// no duplicates
if (running) {
taskQueue.remove();
}
ZoneList task = taskQueue.peek();
if (task != null) {
running = true;
task.execute(this);
} else {
Log.i(TAG, " stopping");
stopSelf();
}
}
@Override
public void onSuccess(Iterator<Zone> zones, long duration) {
running = false;
taskQueue.remove();
bus.post(new ZoneList.SuccessEvent(zones, duration));
executeNext();
}
@Override
public void onFailure(Throwable t) {
bus.post(t);
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
}
| 184 |
0 | Create_ds/denominator/model/src/test/java | Create_ds/denominator/model/src/test/java/denominator/ResourceTypeToValueTest.java | package denominator;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.util.Arrays;
import denominator.ResourceTypeToValue.ResourceTypes;
import static org.assertj.core.api.Assertions.assertThat;
public class ResourceTypeToValueTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void testNiceExceptionOnNotFound() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage(
"ResourceTypes do not include RRRR; types: " + Arrays.asList(ResourceTypes.values()));
ResourceTypeToValue.lookup("RRRR");
}
@Test
public void testNiceExceptionOnNull() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("resource type was null");
ResourceTypeToValue.lookup((String) null);
}
@Test
public void testBasicCase() {
assertThat(ResourceTypeToValue.lookup("AAAA")).isEqualTo(28);
}
}
| 185 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/assertj/ResourceRecordSetAssert.java | package denominator.assertj;
import org.assertj.core.api.AbstractAssert;
import org.assertj.core.internal.Integers;
import org.assertj.core.internal.Iterables;
import org.assertj.core.internal.Maps;
import org.assertj.core.internal.Objects;
import java.util.List;
import java.util.Map;
import denominator.model.ResourceRecordSet;
import denominator.model.profile.Geo;
import static org.assertj.core.data.MapEntry.entry;
import static org.assertj.core.util.Arrays.array;
public class ResourceRecordSetAssert
extends AbstractAssert<ResourceRecordSetAssert, ResourceRecordSet> {
Objects objects = Objects.instance();
Integers integers = Integers.instance();
Iterables iterables = Iterables.instance();
Maps maps = Maps.instance();
public ResourceRecordSetAssert(ResourceRecordSet actual) {
super(actual, ResourceRecordSetAssert.class);
}
public ResourceRecordSetAssert hasName(String expected) {
isNotNull();
objects.assertEqual(info, actual.name(), expected);
return this;
}
public ResourceRecordSetAssert hasType(String expected) {
isNotNull();
objects.assertEqual(info, actual.type(), expected);
return this;
}
public ResourceRecordSetAssert hasQualifier(String expected) {
isNotNull();
objects.assertEqual(info, actual.qualifier(), expected);
return this;
}
public ResourceRecordSetAssert hasTtl(Integer expected) {
isNotNull();
objects.assertEqual(info, actual.ttl(), expected);
return this;
}
/** Asserts {@code records} are the only ones present, in any order. */
public ResourceRecordSetAssert containsOnlyRecords(Map<String, Object>... records) {
iterables.assertContainsOnly(info, actual.records(), records);
return this;
}
public ResourceRecordSetAssert containsExactlyRecords(Map<String, Object>... records) {
iterables.assertContainsExactly(info, actual.records(), records);
return this;
}
public ResourceRecordSetAssert containsExactlyRecords(List<? extends Map<String, Object>> records) {
return containsExactlyRecords(records.toArray(new Map[records.size()]));
}
public ResourceRecordSetAssert hasGeo(Geo expected) {
isNotNull();
objects.assertEqual(info, actual.geo(), expected);
return this;
}
public ResourceRecordSetAssert containsRegion(String region, String... territories) {
isNotNull();
maps.assertContains(info, actual.geo().regions(),
array(entry(region, java.util.Arrays.asList(territories))));
return this;
}
public ResourceRecordSetAssert hasWeight(int expected) {
isNotNull();
objects.assertNotNull(info, actual.weighted());
integers.assertEqual(info, actual.weighted().weight(), expected);
return this;
}
public ResourceRecordSetAssert isValid() {
isNotNull();
objects.assertNotNull(info, actual.name());
objects.assertNotNull(info, actual.type());
iterables.assertNotEmpty(info, actual.records());
return this;
}
public ResourceRecordSetAssert isValidWeighted() {
isValid();
objects.assertNotNull(info, actual.qualifier());
objects.assertNotNull(info, actual.weighted());
integers.assertIsNotNegative(info, actual.weighted().weight());
return this;
}
public ResourceRecordSetAssert isValidGeo() {
isValid();
objects.assertNotNull(info, actual.qualifier());
objects.assertNotNull(info, actual.geo());
maps.assertNotEmpty(info, actual.geo().regions());
return this;
}
}
| 186 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/assertj/ModelAssertions.java | package denominator.assertj;
import org.assertj.core.api.Assertions;
import denominator.model.ResourceRecordSet;
import denominator.model.Zone;
public class ModelAssertions extends Assertions {
public static ResourceRecordSetAssert assertThat(ResourceRecordSet actual) {
return new ResourceRecordSetAssert(actual);
}
public static ZoneAssert assertThat(Zone actual) {
return new ZoneAssert(actual);
}
}
| 187 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/assertj/ZoneAssert.java | package denominator.assertj;
import org.assertj.core.api.AbstractAssert;
import org.assertj.core.internal.Objects;
import org.assertj.core.internal.Strings;
import denominator.model.Zone;
public class ZoneAssert extends AbstractAssert<ZoneAssert, Zone> {
Objects objects = Objects.instance();
Strings strings = Strings.instance();
public ZoneAssert(Zone actual) {
super(actual, ZoneAssert.class);
}
public ZoneAssert hasName(String expected) {
isNotNull();
objects.assertEqual(info, actual.name(), expected);
return this;
}
public ZoneAssert hasId(String expected) {
isNotNull();
objects.assertEqual(info, actual.id(), expected);
return this;
}
/**
* Tolerates differences when the actual email ends with a trailing dot or when the first
* {@literal @} with a dot.
*/
public ZoneAssert hasEmail(String expected) {
isNotNull();
String actualEmail = actual.email();
if (actualEmail.endsWith(".")) {
actualEmail = actualEmail.substring(0, actualEmail.length() - 1);
}
if (actualEmail.indexOf('@') == -1) {
actualEmail = actualEmail.replaceFirst("\\.", "@");
}
strings.assertStartsWith(info, actualEmail, expected);
return this;
}
public ZoneAssert hasTtl(Integer expected) {
isNotNull();
objects.assertEqual(info, actual.ttl(), expected);
return this;
}
}
| 188 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/common/UtilTest.java | package denominator.common;
import denominator.model.rdata.TXTData;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.io.IOException;
import java.io.StringReader;
import java.util.Arrays;
import java.util.Iterator;
import denominator.common.PeekingIteratorTest.TrueThenDone;
import static denominator.common.Util.and;
import static denominator.common.Util.concat;
import static denominator.common.Util.equal;
import static denominator.common.Util.filter;
import static denominator.common.Util.join;
import static denominator.common.Util.nextOrNull;
import static denominator.common.Util.peekingIterator;
import static denominator.common.Util.slurp;
import static denominator.common.Util.split;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class UtilTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void slurpDoesntScrewWithWhitespance() throws IOException {
assertThat(slurp(new StringReader(" foo\n"))).isEqualTo(" foo\n");
}
@Test
public void slurpsLargerThan2KCharBuffer() throws IOException {
StringBuilder builder = new StringBuilder();
for (int i = 0; i < 2001; i++) {
builder.append('a');
}
String twoK1 = builder.toString();
assertThat(slurp(new StringReader(twoK1))).isEqualTo(twoK1);
}
@Test
public void joinNadaReturnsEmpty() {
assertThat(join(';', (Object[]) null)).isEmpty();
assertThat(join(';', new Object[]{})).isEmpty();
}
@Test
public void equalTest() {
assertTrue(equal(null, null));
assertTrue(equal("1", "1"));
assertFalse(equal(null, "1"));
assertFalse(equal("1", null));
assertFalse(equal("1", "2"));
}
@Test
public void joinMultiple() {
assertThat(join(';', "one", 2)).isEqualTo("one;2");
}
@Test
public void splitNull() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("toSplit");
split(';', null);
}
@Test
public void splitMiss() {
assertThat(split(';', "one,2")).containsExactly("one,2");
}
@Test
public void splitWin() {
assertThat(split(';', "one;2;2")).containsExactly("one", "2", "2");
}
@Test
public void splitEmpty() {
assertThat(split(';', "one;;2")).containsExactly("one", null, "2");
assertThat(split(';', ";;")).containsExactly(null, null, null);
}
@Test
public void testNextOrNull() {
PeekingIterator<Boolean> it = TrueThenDone.INSTANCE.iterator();
assertTrue(it.next());
assertThat(nextOrNull(it)).isNull();
}
@Test
public void peekingIteratorWhenPresent() {
PeekingIterator<Boolean> it = peekingIterator(Arrays.asList(true).iterator());
assertTrue(it.peek());
assertThat(it).containsExactly(true);
}
@Test
public void peekingIteratorWhenAbsent() {
PeekingIterator<Object> it = peekingIterator(Arrays.asList().iterator());
assertThat(it).isEmpty();
}
@Test
public void concatIteratorsWhenPresent() {
Iterator<Boolean>
it =
concat(TrueThenDone.INSTANCE.iterator(), TrueThenDone.INSTANCE.iterator());
assertThat(it).containsExactly(true, true);
}
@Test
public void concatIteratorsWhenAbsent() {
Iterator<Boolean> first = TrueThenDone.INSTANCE.iterator();
first.next();
Iterator<Boolean> second = TrueThenDone.INSTANCE.iterator();
second.next();
Iterator<Boolean> it = concat(first, second);
assertThat(it).isEmpty();
}
@Test
public void concatIteratorsWhenFirstIsEmpty() {
Iterator<Boolean> first = TrueThenDone.INSTANCE.iterator();
first.next();
Iterator<Boolean> it = concat(first, TrueThenDone.INSTANCE.iterator());
assertThat(it).containsExactly(true);
}
@Test
public void concatIterablesWhenPresent() {
Iterator<Boolean> it = concat(Arrays.asList(Arrays.asList(true), Arrays.asList(true)));
assertThat(it).containsExactly(true, true);
}
@Test
public void concatIterablesWhenAbsent() {
Iterator<Object> it = concat(Arrays.asList(Arrays.asList(), Arrays.asList()));
assertThat(it).isEmpty();
}
@Test
public void concatIterablesWhenFirstIsEmpty() {
Iterator<Boolean>
it =
concat(Arrays.asList(Arrays.<Boolean>asList(), Arrays.asList(true)));
assertThat(it).containsExactly(true);
}
@Test
public void filterRetains() {
Iterator<String> it = filter(Arrays.asList("waffles", "poo", "pancakes", "eggs").iterator(),
new Filter<String>() {
@Override
public boolean apply(String breakfast) {
return "pancakes".equals(breakfast);
}
});
assertThat(it).containsExactly("pancakes");
}
@Test
public void andFilter() {
Filter<String> startsWithP = new Filter<String>() {
@Override
public boolean apply(String breakfast) {
return breakfast.startsWith("p");
}
};
Filter<String> notPoo = new Filter<String>() {
@Override
public boolean apply(String breakfast) {
return !"poo".equals(breakfast);
}
};
assertTrue(and(startsWithP, notPoo).apply("pancakes"));
assertFalse(and(startsWithP, notPoo).apply("poo"));
}
@Test
public void toMapDoesntSplitTXT() {
assertThat(Util.toMap("TXT", "ONE TWO THREE")).isEqualTo(TXTData.create("ONE TWO THREE"));
}
}
| 189 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/common/PreconditionsTest.java | package denominator.common;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static denominator.common.Preconditions.checkArgument;
import static denominator.common.Preconditions.checkNotNull;
import static denominator.common.Preconditions.checkState;
import static org.assertj.core.api.Assertions.assertThat;
public class PreconditionsTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void checkArgumentFormatted() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("should be foo");
checkArgument(false, "should be %s", "foo");
}
@Test
public void checkArgumentPass() {
checkArgument(true, "should be %s", "foo");
}
@Test
public void checkStateFormatted() {
thrown.expect(IllegalStateException.class);
thrown.expectMessage("should be foo");
checkState(false, "should be %s", "foo");
}
@Test
public void checkStatePass() {
checkState(true, "should be %s", "foo");
}
@Test
public void checkNotNullFormatted() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("should be foo");
checkNotNull(null, "should be %s", "foo");
}
@Test
public void checkNotNullPass() {
assertThat(checkNotNull("foo", "should be %s", "foo")).isEqualTo("foo");
}
}
| 190 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/common/PeekingIteratorTest.java | package denominator.common;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.util.NoSuchElementException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertTrue;
public class PeekingIteratorTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void unmodifiable() {
thrown.expect(UnsupportedOperationException.class);
PeekingIterator<Boolean> it = TrueThenDone.INSTANCE.iterator();
assertThat(it).containsExactly(true);
it.remove();
}
@Test
public void next() {
thrown.expect(NoSuchElementException.class);
PeekingIterator<Boolean> it = TrueThenDone.INSTANCE.iterator();
assertThat(it).containsExactly(true);
it.next();
}
@Test
public void peek() {
thrown.expect(NoSuchElementException.class);
PeekingIterator<Boolean> it = TrueThenDone.INSTANCE.iterator();
assertTrue(it.peek());
assertThat(it).containsExactly(true);
it.peek();
}
enum TrueThenDone implements Iterable<Boolean> {
INSTANCE;
@Override
public PeekingIterator<Boolean> iterator() {
return new PeekingIterator<Boolean>() {
boolean val = true;
@Override
public Boolean computeNext() {
if (val) {
val = false;
return true;
}
return endOfData();
}
};
}
}
}
| 191 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/model/ZonesTest.java | package denominator.model;
import org.junit.Test;
import static denominator.model.Zones.nameEqualTo;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class ZonesTest {
Zone zone = Zone.create("denominator.io.");
@Test
public void nameEqualToReturnsFalseOnNull() {
assertFalse(nameEqualTo(zone.name()).apply(null));
}
@Test
public void nameEqualToReturnsFalseOnDifferentName() {
assertFalse(nameEqualTo("denominator.io").apply(zone));
}
@Test
public void nameEqualToReturnsTrueOnSameName() {
assertTrue(nameEqualTo(zone.name()).apply(zone));
}
}
| 192 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/model/ResourceRecordSetsTest.java | package denominator.model;
import org.junit.Test;
import org.junit.experimental.runners.Enclosed;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import denominator.ResourceTypeToValue;
import denominator.model.profile.Geo;
import denominator.model.rdata.AAAAData;
import denominator.model.rdata.AData;
import denominator.model.rdata.CERTData;
import denominator.model.rdata.CNAMEData;
import denominator.model.rdata.MXData;
import denominator.model.rdata.NAPTRData;
import denominator.model.rdata.NSData;
import denominator.model.rdata.PTRData;
import denominator.model.rdata.SPFData;
import denominator.model.rdata.SRVData;
import denominator.model.rdata.SSHFPData;
import denominator.model.rdata.TXTData;
import static denominator.assertj.ModelAssertions.assertThat;
import static denominator.model.ResourceRecordSets.a;
import static denominator.model.ResourceRecordSets.aaaa;
import static denominator.model.ResourceRecordSets.cert;
import static denominator.model.ResourceRecordSets.cname;
import static denominator.model.ResourceRecordSets.mx;
import static denominator.model.ResourceRecordSets.nameAndTypeEqualTo;
import static denominator.model.ResourceRecordSets.nameEqualTo;
import static denominator.model.ResourceRecordSets.nameTypeAndQualifierEqualTo;
import static denominator.model.ResourceRecordSets.naptr;
import static denominator.model.ResourceRecordSets.ns;
import static denominator.model.ResourceRecordSets.ptr;
import static denominator.model.ResourceRecordSets.spf;
import static denominator.model.ResourceRecordSets.srv;
import static denominator.model.ResourceRecordSets.sshfp;
import static denominator.model.ResourceRecordSets.txt;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@RunWith(Enclosed.class)
public class ResourceRecordSetsTest {
ResourceRecordSet<AData> aRRS = ResourceRecordSet.<AData>builder()
.name("www.denominator.io.")
.type("A")
.ttl(3600)
.add(AData.create("192.0.2.1")).build();
ResourceRecordSet<AData> geoRRS = ResourceRecordSet.<AData>builder()
.name("www.denominator.io.")
.type("A")
.qualifier("US-East")
.ttl(3600)
.add(AData.create("1.1.1.1"))
.geo(Geo.create(new LinkedHashMap<String, Collection<String>>() {
{
put("US", Arrays.asList("US-VA"));
}
})).build();
@Test
public void nameEqualToReturnsFalseOnNull() {
assertFalse(nameEqualTo(aRRS.name()).apply(null));
}
@Test
public void nameEqualToReturnsFalseOnDifferentName() {
assertFalse(nameEqualTo("www.foo.com").apply(aRRS));
}
@Test
public void nameEqualToReturnsTrueOnSameName() {
assertTrue(nameEqualTo(aRRS.name()).apply(aRRS));
}
@Test
public void typeEqualToReturnsFalseOnNull() {
assertFalse(nameAndTypeEqualTo(aRRS.name(), aRRS.type()).apply(null));
}
@Test
public void typeEqualToReturnsFalseOnDifferentType() {
assertFalse(nameAndTypeEqualTo(aRRS.name(), "TXT").apply(aRRS));
}
@Test
public void typeEqualToReturnsTrueOnSameType() {
assertTrue(nameAndTypeEqualTo(aRRS.name(), aRRS.type()).apply(aRRS));
}
@Test
public void containsRecordReturnsFalseOnNull() {
assertFalse(ResourceRecordSets.containsRecord(aRRS.records().get(0)).apply(null));
}
@Test
public void containsRecordReturnsFalseWhenRDataDifferent() {
assertFalse(ResourceRecordSets.containsRecord(AData.create("198.51.100.1")).apply(aRRS));
}
@Test
public void containsRecordReturnsTrueWhenRDataEqual() {
assertTrue(ResourceRecordSets.containsRecord(AData.create("192.0.2.1")).apply(aRRS));
}
@Test
public void containsRecordReturnsTrueWhenRDataEqualButDifferentType() {
Map<String, String> record = new LinkedHashMap<String, String>();
record.put("address", "192.0.2.1");
assertTrue(ResourceRecordSets.containsRecord(record).apply(aRRS));
}
@Test
public void qualifierEqualToReturnsFalseOnNull() {
assertFalse(
nameTypeAndQualifierEqualTo(geoRRS.name(), geoRRS.type(), geoRRS.qualifier()).apply(null));
}
@Test
public void qualifierEqualToReturnsFalseOnDifferentQualifier() {
assertFalse(nameTypeAndQualifierEqualTo(geoRRS.name(), geoRRS.type(), "TXT").apply(geoRRS));
}
@Test
public void qualifierEqualToReturnsFalseOnAbsentQualifier() {
assertFalse(nameTypeAndQualifierEqualTo(geoRRS.name(), geoRRS.type(), "TXT").apply(aRRS));
}
@Test
public void qualifierEqualToReturnsTrueOnSameQualifier() {
assertTrue(nameTypeAndQualifierEqualTo(geoRRS.name(), geoRRS.type(), geoRRS.qualifier())
.apply(geoRRS));
}
@RunWith(Parameterized.class)
public static class ShortFormEqualsLongFormTest {
private final ResourceRecordSet<?> shortForm;
private final ResourceRecordSet<?> longForm;
public ShortFormEqualsLongFormTest(ResourceRecordSet<?> shortForm,
ResourceRecordSet<?> longForm) {
this.shortForm = shortForm;
this.longForm = longForm;
}
@Parameterized.Parameters
public static Iterable<Object[]> data() {
Object[][] data = new Object[33][2];
data[0][0] = a("www.denominator.io.", "192.0.2.1");
data[0][1] = ResourceRecordSet.<AData>builder()
.name("www.denominator.io.")
.type("A")
.add(AData.create("192.0.2.1")).build();
data[1][0] = a("www.denominator.io.", 3600, "192.0.2.1");
data[1][1] = ResourceRecordSet.<AData>builder()
.name("www.denominator.io.")
.type("A")
.ttl(3600)
.add(AData.create("192.0.2.1")).build();
data[2][0] = a("www.denominator.io.", Arrays.asList("192.0.2.1"));
data[2][1] = data[0][1];
data[3][0] = a("www.denominator.io.", 3600, Arrays.asList("192.0.2.1"));
data[3][1] = data[1][1];
data[4][0] = aaaa("www.denominator.io.", "1234:ab00:ff00::6b14:abcd");
data[4][1] = ResourceRecordSet.<AAAAData>builder()
.name("www.denominator.io.")
.type("AAAA")
.add(AAAAData.create("1234:ab00:ff00::6b14:abcd")).build();
data[5][0] = aaaa("www.denominator.io.", 3600, "1234:ab00:ff00::6b14:abcd");
data[5][1] = ResourceRecordSet.<AAAAData>builder()
.name("www.denominator.io.")
.type("AAAA")
.ttl(3600)
.add(AAAAData.create("1234:ab00:ff00::6b14:abcd")).build();
data[6][0] = aaaa("www.denominator.io.", Arrays.asList("1234:ab00:ff00::6b14:abcd"));
data[6][1] = data[4][1];
data[7][0] = aaaa("www.denominator.io.", 3600, Arrays.asList("1234:ab00:ff00::6b14:abcd"));
data[7][1] = data[5][1];
data[8][0] = cname("www.denominator.io.", "www1.denominator.io.");
data[8][1] = ResourceRecordSet.<CNAMEData>builder()
.name("www.denominator.io.")
.type("CNAME")
.add(CNAMEData.create("www1.denominator.io.")).build();
data[9][0] = cname("www.denominator.io.", 3600, "www1.denominator.io.");
data[9][1] = ResourceRecordSet.<CNAMEData>builder()
.name("www.denominator.io.")
.type("CNAME")
.ttl(3600)
.add(CNAMEData.create("www1.denominator.io.")).build();
data[10][0] = cname("www.denominator.io.", Arrays.asList("www1.denominator.io."));
data[10][1] = data[8][1];
data[11][0] = cname("www.denominator.io.", 3600, Arrays.asList("www1.denominator.io."));
data[11][1] = data[9][1];
data[12][0] = ns("denominator.io.", "ns.denominator.io.");
data[12][1] = ResourceRecordSet.<NSData>builder()
.name("denominator.io.")
.type("NS")
.add(NSData.create("ns.denominator.io.")).build();
data[13][0] = ns("denominator.io.", 3600, "ns.denominator.io.");
data[13][1] = ResourceRecordSet.<NSData>builder()
.name("denominator.io.")
.type("NS")
.ttl(3600)
.add(NSData.create("ns.denominator.io.")).build();
data[14][0] = ns("denominator.io.", Arrays.asList("ns.denominator.io."));
data[14][1] = data[12][1];
data[15][0] = ns("denominator.io.", 3600, Arrays.asList("ns.denominator.io."));
data[15][1] = data[13][1];
data[16][0] = ptr("denominator.io.", "ptr.denominator.io.");
data[16][1] = ResourceRecordSet.<PTRData>builder()
.name("denominator.io.")
.type("PTR")
.add(PTRData.create("ptr.denominator.io.")).build();
data[17][0] = ptr("denominator.io.", 3600, "ptr.denominator.io.");
data[17][1] = ResourceRecordSet.<PTRData>builder()
.name("denominator.io.")
.type("PTR")
.ttl(3600)
.add(PTRData.create("ptr.denominator.io.")).build();
data[18][0] = ptr("denominator.io.", Arrays.asList("ptr.denominator.io."));
data[18][1] = data[16][1];
data[19][0] = ptr("denominator.io.", 3600, Arrays.asList("ptr.denominator.io."));
data[19][1] = data[17][1];
data[20][0] = txt("denominator.io.", "\"made in sweden\"");
data[20][1] = ResourceRecordSet.<TXTData>builder()
.name("denominator.io.")
.type("TXT")
.add(TXTData.create("\"made in sweden\"")).build();
data[21][0] = txt("denominator.io.", 3600, "\"made in sweden\"");
data[21][1] = ResourceRecordSet.<TXTData>builder()
.name("denominator.io.")
.type("TXT")
.ttl(3600)
.add(TXTData.create("\"made in sweden\"")).build();
data[22][0] = txt("denominator.io.", Arrays.asList("\"made in sweden\""));
data[22][1] = data[20][1];
data[23][0] = txt("denominator.io.", 3600, Arrays.asList("\"made in sweden\""));
data[23][1] = data[21][1];
data[24][0] = spf("denominator.io.", "\"v=spf1 a mx -all\"");
data[24][1] = ResourceRecordSet.<SPFData>builder()
.name("denominator.io.")
.type("SPF")
.add(SPFData.create("\"v=spf1 a mx -all\"")).build();
data[25][0] = spf("denominator.io.", 3600, "\"v=spf1 a mx -all\"");
data[25][1] = ResourceRecordSet.<SPFData>builder()
.name("denominator.io.")
.type("SPF")
.ttl(3600)
.add(SPFData.create("\"v=spf1 a mx -all\"")).build();
data[26][0] = spf("denominator.io.", Arrays.asList("\"v=spf1 a mx -all\""));
data[26][1] = data[24][1];
data[27][0] = spf("denominator.io.", 3600, Arrays.asList("\"v=spf1 a mx -all\""));
data[27][1] = data[25][1];
data[28][0] = mx("denominator.io.", 3600, Arrays.asList("1 mx1.denominator.io."));
data[28][1] = ResourceRecordSet.<MXData>builder()
.name("denominator.io.")
.type("MX")
.ttl(3600)
.add(MXData.create(1, "mx1.denominator.io.")).build();
data[29][0] = srv("denominator.io.", 3600, Arrays.asList("0 1 80 srv.denominator.io."));
data[29][1] = ResourceRecordSet.<SRVData>builder()
.name("denominator.io.")
.type("SRV")
.ttl(3600)
.add(SRVData.builder().priority(0).weight(1).port(80).target("srv.denominator.io.")
.build())
.build();
data[30][0] = cert("www.denominator.io.", 3600, Arrays.asList("12345 1 1 B33F"));
data[30][1] = ResourceRecordSet.<CERTData>builder()
.name("www.denominator.io.")
.type("CERT")
.ttl(3600)
.add(CERTData.builder().format(12345).tag(1).algorithm(1).certificate("B33F").build())
.build();
data[31][0] =
naptr("phone.denominator.io.", 3600,
Arrays.asList("1 1 U E2U+sip !^.*$!sip:customer-service@example.com! ."));
data[31][1] = ResourceRecordSet.<NAPTRData>builder()
.name("phone.denominator.io.")
.type("NAPTR")
.ttl(3600)
.add(NAPTRData.builder().order(1).preference(1).flags("U").services("E2U+sip")
.regexp("!^.*$!sip:customer-service@example.com!").replacement(".").build())
.build();
data[32][0] =
sshfp("server1.denominator.io.", 3600,
Arrays.asList("2 1 123456789abcdef67890123456789abcdef67890"));
data[32][1] = ResourceRecordSet.<SSHFPData>builder()
.name("server1.denominator.io.")
.type("SSHFP")
.ttl(3600)
.add(SSHFPData.createDSA("123456789abcdef67890123456789abcdef67890")).build();
return Arrays.asList(data);
}
@Test
public void shortFormEqualsLongForm() throws IOException {
assertThat(shortForm)
.isEqualTo(longForm)
.hasName(longForm.name())
.hasType(longForm.type())
.hasTtl(longForm.ttl())
.containsExactlyRecords(longForm.records());
ResourceTypeToValue.lookup(longForm.type());
}
}
}
| 193 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/model/ResourceRecordSetTest.java | package denominator.model;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import denominator.model.rdata.AData;
import static denominator.assertj.ModelAssertions.assertThat;
public class ResourceRecordSetTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void canBuildARecordSetInLongForm() {
ResourceRecordSet<AData> record = ResourceRecordSet.<AData>builder()
.name("www.denominator.io.")
.type("A")
.ttl(3600)
.add(AData.create("192.0.2.1")).build();
assertThat(record)
.hasName("www.denominator.io.")
.hasType("A")
.hasTtl(3600)
.containsExactlyRecords(AData.create("192.0.2.1"));
}
@Test
public void testNullRdataNPE() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("record");
ResourceRecordSet.<AData>builder().add(null);
}
@Test
public void testInvalidTTL() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Invalid ttl");
ResourceRecordSet.<AData>builder()//
.name("www.denominator.io.")//
.type("A")//
.ttl(0xFFFFFFFF)//
.add(AData.create("192.0.2.1")).build();
}
}
| 194 |
0 | Create_ds/denominator/model/src/test/java/denominator | Create_ds/denominator/model/src/test/java/denominator/model/ZoneTest.java | package denominator.model;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static denominator.assertj.ModelAssertions.assertThat;
public class ZoneTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void factoryMethodsWork() {
Zone name = Zone.create("denominator.io.");
Zone id = Zone.create("denominator.io.", "ABCD");
Zone email = Zone.create("ABCD", "denominator.io.", 1800, "admin@foo.com");
assertThat(name)
.hasId("denominator.io.")
.hasName("denominator.io.")
.hasTtl(86400)
.hasEmail("nil@denominator.io")
.isEqualTo(name)
.isNotEqualTo(id)
.isNotEqualTo(email);
assertThat(name.hashCode())
.isNotEqualTo(id.hashCode())
.isNotEqualTo(email.hashCode());
assertThat(name.toString())
.isEqualTo("Zone [name=denominator.io., ttl=86400, email=nil@denominator.io.]");
assertThat(id)
.hasId("ABCD")
.hasName("denominator.io.")
.hasTtl(86400)
.hasEmail("nil@denominator.io")
.isEqualTo(id)
.isNotEqualTo(name)
.isNotEqualTo(email);
assertThat(id.hashCode())
.isNotEqualTo(name.hashCode())
.isNotEqualTo(email.hashCode());
assertThat(id.toString()).isEqualTo(
"Zone [id=ABCD, name=denominator.io., ttl=86400, email=nil@denominator.io.]");
assertThat(email)
.hasId("ABCD")
.hasName("denominator.io.")
.hasTtl(1800)
.hasEmail("admin@foo.com")
.isEqualTo(email)
.isNotEqualTo(name)
.isNotEqualTo(id);
assertThat(email.hashCode())
.isNotEqualTo(name.hashCode())
.isNotEqualTo(id.hashCode());
assertThat(email.toString()).isEqualTo(
"Zone [id=ABCD, name=denominator.io., ttl=1800, email=admin@foo.com]");
}
@Test
public void nullNameNPEMessage() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("name");
Zone.create(null);
}
@Test
public void nullEmailNameNPEMessage() {
thrown.expect(NullPointerException.class);
thrown.expectMessage("email");
Zone.create(null, "name", 1800, null);
}
@Test
public void negativeTtl() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("Invalid ttl value: -1, must be 0-2147483647");
Zone.create("ABCD", "denominator.io.", -1, "admin@foo.com");
}
}
| 195 |
0 | Create_ds/denominator/model/src/test/java/denominator/model | Create_ds/denominator/model/src/test/java/denominator/model/rdata/AAAADataTest.java | package denominator.model.rdata;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static denominator.model.ResourceRecordSets.aaaa;
public class AAAADataTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void testBadIPv4() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("should be a ipv6 address");
aaaa("www.denominator.io.", "192.0.2.1");
}
@Test
public void testNoIP() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("should be a ipv6 address");
aaaa("www.denominator.io.", "");
}
@Test
public void testGoodIPv6() {
aaaa("www.denominator.io.", "2001:db8:1cfe:face:b00c::3");
}
}
| 196 |
0 | Create_ds/denominator/model/src/test/java/denominator/model | Create_ds/denominator/model/src/test/java/denominator/model/rdata/ADataTest.java | package denominator.model.rdata;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static denominator.model.ResourceRecordSets.a;
public class ADataTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void testBadIPv6() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("should be a ipv4 address");
a("www.denominator.io.", "2001:db8:1cfe:face:b00c::3");
}
@Test
public void testNoIP() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("should be a ipv4 address");
a("www.denominator.io.", "");
}
@Test
public void testGoodIPv4() {
a("www.denominator.io.", "192.0.2.1");
}
}
| 197 |
0 | Create_ds/denominator/model/src/test/java/denominator/model | Create_ds/denominator/model/src/test/java/denominator/model/rdata/TXTDataTest.java | package denominator.model.rdata;
import org.junit.Test;
import static denominator.model.ResourceRecordSets.txt;
public class TXTDataTest {
@Test
public void testSinglePart() {
txt("www.denominator.io.", "foo");
}
@Test
public void testMultiPart() {
txt("www.denominator.io.", "\"foo bar\"");
}
}
| 198 |
0 | Create_ds/denominator/model/src/test/java/denominator/model | Create_ds/denominator/model/src/test/java/denominator/model/rdata/CERTDataTest.java | package denominator.model.rdata;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import static denominator.model.ResourceRecordSets.cert;
public class CERTDataTest {
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test
public void testGoodRecord() {
cert("www.denominator.io.", "12345 1 1 B33F");
}
@Test
public void testMissingParts() {
thrown.expect(IllegalArgumentException.class);
thrown.expectMessage("record must have exactly four parts");
cert("www.denominator.io.", "12345 1 1");
}
}
| 199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.