diff --git a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/CloudStackAsyncClient.java b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/CloudStackAsyncClient.java index 914da9497a..2aac2dfe06 100644 --- a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/CloudStackAsyncClient.java +++ b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/CloudStackAsyncClient.java @@ -21,6 +21,7 @@ package org.jclouds.cloudstack; import org.jclouds.cloudstack.features.AddressAsyncClient; import org.jclouds.cloudstack.features.AsyncJobAsyncClient; +import org.jclouds.cloudstack.features.NATAsyncClient; import org.jclouds.cloudstack.features.NetworkAsyncClient; import org.jclouds.cloudstack.features.OfferingAsyncClient; import org.jclouds.cloudstack.features.SecurityGroupAsyncClient; @@ -86,4 +87,10 @@ public interface CloudStackAsyncClient { */ @Delegate AddressAsyncClient getAddressClient(); + + /** + * Provides asynchronous access to NAT features. + */ + @Delegate + NATAsyncClient getNATClient(); } diff --git a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/CloudStackClient.java b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/CloudStackClient.java index c2e85a83ca..b4084bbc64 100644 --- a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/CloudStackClient.java +++ b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/CloudStackClient.java @@ -23,6 +23,7 @@ import java.util.concurrent.TimeUnit; import org.jclouds.cloudstack.features.AddressClient; import org.jclouds.cloudstack.features.AsyncJobClient; +import org.jclouds.cloudstack.features.NATClient; import org.jclouds.cloudstack.features.NetworkClient; import org.jclouds.cloudstack.features.OfferingClient; import org.jclouds.cloudstack.features.SecurityGroupClient; @@ -89,4 +90,10 @@ public interface CloudStackClient { */ @Delegate AddressClient getAddressClient(); + + /** + * Provides synchronous access to NAT features. + */ + @Delegate + NATClient getNATClient(); } diff --git a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/config/CloudStackRestClientModule.java b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/config/CloudStackRestClientModule.java index 8cc4a80085..e1473263fd 100644 --- a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/config/CloudStackRestClientModule.java +++ b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/config/CloudStackRestClientModule.java @@ -27,6 +27,8 @@ import org.jclouds.cloudstack.features.AddressAsyncClient; import org.jclouds.cloudstack.features.AddressClient; import org.jclouds.cloudstack.features.AsyncJobAsyncClient; import org.jclouds.cloudstack.features.AsyncJobClient; +import org.jclouds.cloudstack.features.NATAsyncClient; +import org.jclouds.cloudstack.features.NATClient; import org.jclouds.cloudstack.features.NetworkAsyncClient; import org.jclouds.cloudstack.features.NetworkClient; import org.jclouds.cloudstack.features.OfferingAsyncClient; @@ -70,6 +72,7 @@ public class CloudStackRestClientModule extends RestClientModule + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.domain; + +import com.google.gson.annotations.SerializedName; + +/** + * + * @author Adrian Cole + */ +public class IPForwardingRule implements Comparable { + public static Builder builder() { + return new Builder(); + } + + public static class Builder { + private long id; + private String IPAddress; + private long IPAddressId; + private int privatePort; + private String protocol; + public int publicPort; + private String state; + private String virtualMachineDisplayName; + public long virtualMachineId; + private String virtualMachineName; + + public Builder id(long id) { + this.id = id; + return this; + } + + public Builder IPAddress(String IPAddress) { + this.IPAddress = IPAddress; + return this; + } + + public Builder IPAddressId(long IPAddressId) { + this.IPAddressId = IPAddressId; + return this; + } + + public Builder privatePort(int privatePort) { + this.privatePort = privatePort; + return this; + } + + public Builder protocol(String protocol) { + this.protocol = protocol; + return this; + } + + public Builder publicPort(int publicPort) { + this.publicPort = publicPort; + return this; + } + + public Builder state(String state) { + this.state = state; + return this; + } + + public Builder virtualMachineDisplayName(String virtualMachineDisplayName) { + this.virtualMachineDisplayName = virtualMachineDisplayName; + return this; + } + + public Builder virtualMachineId(long virtualMachineId) { + this.virtualMachineId = virtualMachineId; + return this; + } + + public Builder virtualMachineName(String virtualMachineName) { + this.virtualMachineName = virtualMachineName; + return this; + } + + public IPForwardingRule build() { + return new IPForwardingRule(id, IPAddress, IPAddressId, privatePort, protocol, publicPort, state, + virtualMachineDisplayName, virtualMachineId, virtualMachineName); + } + } + + private long id; + @SerializedName("ipaddress") + private String IPAddress; + @SerializedName("ipaddressid") + private long IPAddressId; + @SerializedName("privateport") + private int privatePort; + private String protocol; + @SerializedName("publicport") + public int publicPort; + private String state; + @SerializedName("virtualmachinedisplayname") + private String virtualMachineDisplayName; + @SerializedName("virtualmachineid") + public long virtualMachineId; + @SerializedName("virtualmachinename") + private String virtualMachineName; + + public IPForwardingRule(long id, String iPAddress, long iPAddressId, int privatePort, String protocol, + int publicPort, String state, String virtualMachineDisplayName, long virtualMachineId, + String virtualMachineName) { + this.id = id; + this.IPAddress = iPAddress; + this.IPAddressId = iPAddressId; + this.privatePort = privatePort; + this.protocol = protocol; + this.publicPort = publicPort; + this.state = state; + this.virtualMachineDisplayName = virtualMachineDisplayName; + this.virtualMachineId = virtualMachineId; + this.virtualMachineName = virtualMachineName; + } + + @Override + public int compareTo(IPForwardingRule arg0) { + return new Long(id).compareTo(arg0.getId()); + } + + /** + * + * @return the ID of the port forwarding rule + */ + public long getId() { + return id; + } + + /** + * + * @return the public ip address for the port forwarding rule + */ + public String getIPAddress() { + return IPAddress; + } + + /** + * + * @return the public ip address id for the port forwarding rule + */ + public long getIPAddressId() { + return IPAddressId; + } + + /** + * + * @return the private port for the port forwarding rule + */ + public int getPrivatePort() { + return privatePort; + } + + /** + * + * @return the protocol of the port forwarding rule + */ + public String getProtocol() { + return protocol; + } + + /** + * + * @return the public port for the port forwarding rule + */ + public int getPublicPort() { + return publicPort; + } + + /** + * + * @return the state of the rule + */ + public String getState() { + return state; + } + + /** + * + * @return the VM display name for the port forwarding rule + */ + public String getVirtualMachineDisplayName() { + return virtualMachineDisplayName; + } + + /** + * + * @return the VM ID for the port forwarding rule + */ + public long getVirtualMachineId() { + return virtualMachineId; + } + + /** + * + * @return the VM name for the port forwarding rule + */ + public String getVirtualMachineName() { + return virtualMachineName; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((IPAddress == null) ? 0 : IPAddress.hashCode()); + result = prime * result + (int) (IPAddressId ^ (IPAddressId >>> 32)); + result = prime * result + (int) (id ^ (id >>> 32)); + result = prime * result + privatePort; + result = prime * result + ((protocol == null) ? 0 : protocol.hashCode()); + result = prime * result + publicPort; + result = prime * result + ((state == null) ? 0 : state.hashCode()); + result = prime * result + ((virtualMachineDisplayName == null) ? 0 : virtualMachineDisplayName.hashCode()); + result = prime * result + (int) (virtualMachineId ^ (virtualMachineId >>> 32)); + result = prime * result + ((virtualMachineName == null) ? 0 : virtualMachineName.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + IPForwardingRule other = (IPForwardingRule) obj; + if (IPAddress == null) { + if (other.IPAddress != null) + return false; + } else if (!IPAddress.equals(other.IPAddress)) + return false; + if (IPAddressId != other.IPAddressId) + return false; + if (id != other.id) + return false; + if (privatePort != other.privatePort) + return false; + if (protocol == null) { + if (other.protocol != null) + return false; + } else if (!protocol.equals(other.protocol)) + return false; + if (publicPort != other.publicPort) + return false; + if (state == null) { + if (other.state != null) + return false; + } else if (!state.equals(other.state)) + return false; + if (virtualMachineDisplayName == null) { + if (other.virtualMachineDisplayName != null) + return false; + } else if (!virtualMachineDisplayName.equals(other.virtualMachineDisplayName)) + return false; + if (virtualMachineId != other.virtualMachineId) + return false; + if (virtualMachineName == null) { + if (other.virtualMachineName != null) + return false; + } else if (!virtualMachineName.equals(other.virtualMachineName)) + return false; + return true; + } + + @Override + public String toString() { + return "[IPAddress=" + IPAddress + ", IPAddressId=" + IPAddressId + ", id=" + id + ", privatePort=" + privatePort + + ", protocol=" + protocol + ", publicPort=" + publicPort + ", state=" + state + + ", virtualMachineDisplayName=" + virtualMachineDisplayName + ", virtualMachineId=" + virtualMachineId + + ", virtualMachineName=" + virtualMachineName + "]"; + } + +} diff --git a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/NATAsyncClient.java b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/NATAsyncClient.java new file mode 100644 index 0000000000..23ff38f883 --- /dev/null +++ b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/NATAsyncClient.java @@ -0,0 +1,96 @@ +/** + * + * Copyright (C) 2010 Cloud Conscious, LLC. + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.features; + +import java.util.Set; + +import javax.ws.rs.Consumes; +import javax.ws.rs.GET; +import javax.ws.rs.QueryParam; +import javax.ws.rs.core.MediaType; + +import org.jclouds.cloudstack.domain.AsyncCreateResponse; +import org.jclouds.cloudstack.domain.IPForwardingRule; +import org.jclouds.cloudstack.filters.QuerySigner; +import org.jclouds.cloudstack.options.CreateIPForwardingRuleOptions; +import org.jclouds.cloudstack.options.ListIPForwardingRulesOptions; +import org.jclouds.rest.annotations.ExceptionParser; +import org.jclouds.rest.annotations.QueryParams; +import org.jclouds.rest.annotations.RequestFilters; +import org.jclouds.rest.annotations.Unwrap; +import org.jclouds.rest.functions.ReturnEmptySetOnNotFoundOr404; +import org.jclouds.rest.functions.ReturnNullOnNotFoundOr404; +import org.jclouds.rest.functions.ReturnVoidOnNotFoundOr404; + +import com.google.common.util.concurrent.ListenableFuture; + +/** + * Provides asynchronous access to cloudstack via their REST API. + *

+ * + * @see NATClient + * @see + * @author Adrian Cole + */ +@RequestFilters(QuerySigner.class) +@QueryParams(keys = "response", values = "json") +public interface NATAsyncClient { + + /** + * @see NATClient#listIPForwardingRules + */ + @GET + @QueryParams(keys = "command", values = "listIpForwardingRules") + @Unwrap(depth = 2) + @Consumes(MediaType.APPLICATION_JSON) + @ExceptionParser(ReturnEmptySetOnNotFoundOr404.class) + ListenableFuture> listIPForwardingRules(ListIPForwardingRulesOptions... options); + + /** + * @see NATClient#getIPForwardingRule + */ + @GET + @QueryParams(keys = "command", values = "listIpForwardingRules") + @Unwrap(depth = 3, edgeCollection = Set.class) + @Consumes(MediaType.APPLICATION_JSON) + @ExceptionParser(ReturnNullOnNotFoundOr404.class) + ListenableFuture getIPForwardingRule(@QueryParam("id") long id); + + /** + * @see NATClient#createIPForwardingRuleForVirtualMachine + */ + @GET + @QueryParams(keys = "command", values = "createIpForwardingRule") + @Unwrap + @Consumes(MediaType.APPLICATION_JSON) + ListenableFuture createIPForwardingRuleForVirtualMachine( + @QueryParam("virtualmachineid") long virtualMachineId, @QueryParam("ipaddressid") long IPAddressId, + @QueryParam("protocol") String protocol, @QueryParam("startport") int startPort, + CreateIPForwardingRuleOptions... options); + + /** + * @see NATClient#deleteIpForwardingRule + */ + @GET + @QueryParams(keys = "command", values = "deleteIpForwardingRule") + @ExceptionParser(ReturnVoidOnNotFoundOr404.class) + ListenableFuture deleteIPForwardingRule(@QueryParam("id") long id); + +} diff --git a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/NATClient.java b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/NATClient.java new file mode 100644 index 0000000000..4892451e8c --- /dev/null +++ b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/features/NATClient.java @@ -0,0 +1,83 @@ +/** + * + * Copyright (C) 2010 Cloud Conscious, LLC. + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.features; + +import java.util.Set; +import java.util.concurrent.TimeUnit; + +import org.jclouds.cloudstack.domain.AsyncCreateResponse; +import org.jclouds.cloudstack.domain.IPForwardingRule; +import org.jclouds.cloudstack.options.CreateIPForwardingRuleOptions; +import org.jclouds.cloudstack.options.ListIPForwardingRulesOptions; +import org.jclouds.concurrent.Timeout; + +/** + * Provides synchronous access to CloudStack IPForwardingRule features. + *

+ * + * @see IPForwardingRuleAsyncClient + * @see + * @author Adrian Cole + */ +@Timeout(duration = 60, timeUnit = TimeUnit.SECONDS) +public interface NATClient { + /** + * List the ip forwarding rules + * + * @param options + * if present, how to constrain the list. + * @return IPForwardingRulees matching query, or empty set, if no IPForwardingRulees are found + */ + Set listIPForwardingRules(ListIPForwardingRulesOptions... options); + + /** + * get a specific IPForwardingRule by id + * + * @param id + * IPForwardingRule to get + * @return IPForwardingRule or null if not found + */ + IPForwardingRule getIPForwardingRule(long id); + + /** + * Creates an ip forwarding rule + * + * @param virtualMachineId + * the virtual machine this rule applies to. + * + * @param IPAddressId + * the public IP address id of the forwarding rule, already associated via associateIp + * @param protocol + * the protocol for the rule. Valid values are TCP or UDP. + * @param startPort + * the start port for the rule + * @return response used to track creation + */ + AsyncCreateResponse createIPForwardingRuleForVirtualMachine(long virtualMachineId, long IPAddressId, + String protocol, int startPort, CreateIPForwardingRuleOptions... options); + + /** + * Deletes an ip forwarding rule + * + * @param id + * the id of the forwarding rule + */ + void deleteIPForwardingRule(long id); +} diff --git a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/options/CreateIPForwardingRuleOptions.java b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/options/CreateIPForwardingRuleOptions.java new file mode 100644 index 0000000000..7c56aeba56 --- /dev/null +++ b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/options/CreateIPForwardingRuleOptions.java @@ -0,0 +1,56 @@ +/** + * + * Copyright (C) 2010 Cloud Conscious, LLC. + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.options; + +import org.jclouds.http.options.BaseHttpRequestOptions; + +import com.google.common.collect.ImmutableSet; + +/** + * Options used to create an ip forwarding rule + * + * @see + * @author Adrian Cole + */ +public class CreateIPForwardingRuleOptions extends BaseHttpRequestOptions { + + public static final CreateIPForwardingRuleOptions NONE = new CreateIPForwardingRuleOptions(); + + /** + * @param endPort + * the end port for the rule + */ + public CreateIPForwardingRuleOptions endPort(int endPort) { + this.queryParameters.replaceValues("endport", ImmutableSet.of(endPort + "")); + return this; + + } + + public static class Builder { + + /** + * @see CreateIPForwardingRuleOptions#endPort + */ + public static CreateIPForwardingRuleOptions endPort(int endPort) { + CreateIPForwardingRuleOptions options = new CreateIPForwardingRuleOptions(); + return options.endPort(endPort); + } + } +} diff --git a/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/options/ListIPForwardingRulesOptions.java b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/options/ListIPForwardingRulesOptions.java new file mode 100644 index 0000000000..3ee83da617 --- /dev/null +++ b/sandbox-apis/cloudstack/src/main/java/org/jclouds/cloudstack/options/ListIPForwardingRulesOptions.java @@ -0,0 +1,128 @@ +/** + * + * Copyright (C) 2010 Cloud Conscious, LLC. + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.options; + +import org.jclouds.http.options.BaseHttpRequestOptions; + +import com.google.common.collect.ImmutableSet; + +/** + * Options used to control what ip forwarding rules are returned + * + * @see + * @author Adrian Cole + */ +public class ListIPForwardingRulesOptions extends BaseHttpRequestOptions { + + public static final ListIPForwardingRulesOptions NONE = new ListIPForwardingRulesOptions(); + + /** + * @param id + * Lists rule with the specified ID. + */ + public ListIPForwardingRulesOptions id(long id) { + this.queryParameters.replaceValues("id", ImmutableSet.of(id + "")); + return this; + } + + /** + * @param domainId + * Lists all rules for this id. If used with the account parameter, returns all rules + * for an account in the specified domain ID. + */ + public ListIPForwardingRulesOptions domainId(long domainId) { + this.queryParameters.replaceValues("domainid", ImmutableSet.of(domainId + "")); + return this; + + } + + /** + * @param account + * the account associated with the ip forwarding rule. Must be used with the domainId + * parameter. + */ + public ListIPForwardingRulesOptions account(String account) { + this.queryParameters.replaceValues("account", ImmutableSet.of(account)); + return this; + } + + /** + * @param IPAddressId + * list the rule belonging to this public ip address + */ + public ListIPForwardingRulesOptions IPAddressId(long IPAddressId) { + this.queryParameters.replaceValues("ipaddressid", ImmutableSet.of(IPAddressId + "")); + return this; + + } + + /** + * @param virtualMachineId + * Lists all rules applied to the specified Vm. + */ + public ListIPForwardingRulesOptions virtualMachineId(long virtualMachineId) { + this.queryParameters.replaceValues("virtualmachineid", ImmutableSet.of(virtualMachineId + "")); + return this; + + } + + public static class Builder { + + /** + * @see ListIPForwardingRulesOptions#account + */ + public static ListIPForwardingRulesOptions account(String account) { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions(); + return options.account(account); + } + + /** + * @see ListIPForwardingRulesOptions#IPAddressId + */ + public static ListIPForwardingRulesOptions IPAddressId(long IPAddressId) { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions(); + return options.IPAddressId(IPAddressId); + } + + /** + * @see ListIPForwardingRulesOptions#domainId + */ + public static ListIPForwardingRulesOptions domainId(long id) { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions(); + return options.domainId(id); + } + + /** + * @see ListIPForwardingRulesOptions#id + */ + public static ListIPForwardingRulesOptions id(long id) { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions(); + return options.id(id); + } + + /** + * @see ListIPForwardingRulesOptions#virtualMachineId + */ + public static ListIPForwardingRulesOptions virtualMachineId(long virtualMachineId) { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions(); + return options.virtualMachineId(virtualMachineId); + } + } +} diff --git a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/AddressClientLiveTest.java b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/AddressClientLiveTest.java index 6f3b2e7399..68cf537887 100644 --- a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/AddressClientLiveTest.java +++ b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/AddressClientLiveTest.java @@ -19,7 +19,7 @@ package org.jclouds.cloudstack.features; -import static com.google.common.collect.Iterables.get; +import static com.google.common.collect.Iterables.find; import static com.google.common.collect.Iterables.getOnlyElement; import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertTrue; @@ -27,7 +27,9 @@ import static org.testng.Assert.assertTrue; import java.util.Set; import java.util.concurrent.TimeUnit; +import org.jclouds.cloudstack.CloudStackClient; import org.jclouds.cloudstack.domain.AsyncCreateResponse; +import org.jclouds.cloudstack.domain.NetworkType; import org.jclouds.cloudstack.domain.PublicIPAddress; import org.jclouds.cloudstack.domain.Zone; import org.jclouds.cloudstack.options.ListPublicIPAddressesOptions; @@ -37,6 +39,8 @@ import org.testng.annotations.AfterGroups; import org.testng.annotations.BeforeGroups; import org.testng.annotations.Test; +import com.google.common.base.Predicate; + /** * Tests behavior of {@code PublicIPAddressClientLiveTest} * @@ -54,13 +58,28 @@ public class AddressClientLiveTest extends BaseCloudStackClientLiveTest { } public void testAssociateDisassociatePublicIPAddress() throws Exception { - final Zone zone = get(client.getZoneClient().listZones(), 0); + ip = createPublicIPAddress(client, jobComplete); + checkIP(ip); + } + public static PublicIPAddress createPublicIPAddress(CloudStackClient client, RetryablePredicate jobComplete) { + Zone zone = find(client.getZoneClient().listZones(), new Predicate() { + + @Override + public boolean apply(Zone arg0) { + return arg0.getNetworkType() == NetworkType.ADVANCED; + } + + @Override + public String toString() { + return "networkType(ADVANCED)"; + } + }); AsyncCreateResponse job = client.getAddressClient().associateIPAddress(zone.getId()); assert jobComplete.apply(job.getJobId()); - ip = client.getAddressClient().getPublicIPAddress(job.getId()); + PublicIPAddress ip = client.getAddressClient().getPublicIPAddress(job.getId()); assertEquals(ip.getZoneId(), zone.getId()); - checkIP(ip); + return ip; } @AfterGroups(groups = "live") diff --git a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/BaseCloudStackClientLiveTest.java b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/BaseCloudStackClientLiveTest.java index b6fe91afb6..87927f66cf 100644 --- a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/BaseCloudStackClientLiveTest.java +++ b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/BaseCloudStackClientLiveTest.java @@ -27,6 +27,10 @@ import java.util.concurrent.TimeUnit; import org.jclouds.Constants; import org.jclouds.cloudstack.CloudStackAsyncClient; import org.jclouds.cloudstack.CloudStackClient; +import org.jclouds.cloudstack.domain.VirtualMachine; +import org.jclouds.cloudstack.predicates.JobComplete; +import org.jclouds.cloudstack.predicates.VirtualMachineDestroyed; +import org.jclouds.cloudstack.predicates.VirtualMachineRunning; import org.jclouds.logging.log4j.config.Log4JLoggingModule; import org.jclouds.net.IPSocket; import org.jclouds.predicates.InetSocketAddressConnect; @@ -55,7 +59,10 @@ public class BaseCloudStackClientLiveTest { protected String endpoint; protected String apiversion; protected Predicate socketTester; - + protected RetryablePredicate jobComplete; + protected RetryablePredicate virtualMachineRunning; + protected RetryablePredicate virtualMachineDestroyed; + protected void setupCredentials() { identity = checkNotNull(System.getProperty("test." + provider + ".identity"), "test." + provider + ".identity must be set. ex. apiKey"); @@ -87,6 +94,11 @@ public class BaseCloudStackClientLiveTest { client = context.getApi(); socketTester = new RetryablePredicate(new InetSocketAddressConnect(), 180, 1, TimeUnit.SECONDS); + jobComplete = new RetryablePredicate(new JobComplete(client), 600, 5, TimeUnit.SECONDS); + virtualMachineRunning = new RetryablePredicate(new VirtualMachineRunning(client), 600, 5, + TimeUnit.SECONDS); + virtualMachineDestroyed = new RetryablePredicate(new VirtualMachineDestroyed(client), 600, 5, + TimeUnit.SECONDS); } @AfterGroups(groups = "live") diff --git a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/NATAsyncClientTest.java b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/NATAsyncClientTest.java new file mode 100644 index 0000000000..aa8a803b2d --- /dev/null +++ b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/NATAsyncClientTest.java @@ -0,0 +1,163 @@ +/** + * + * Copyright (C) 2010 Cloud Conscious, LLC. + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.features; + +import java.io.IOException; +import java.lang.reflect.Method; + +import org.jclouds.cloudstack.options.CreateIPForwardingRuleOptions; +import org.jclouds.cloudstack.options.ListIPForwardingRulesOptions; +import org.jclouds.http.HttpRequest; +import org.jclouds.http.functions.ReleasePayloadAndReturn; +import org.jclouds.http.functions.UnwrapOnlyJsonValue; +import org.jclouds.http.functions.UnwrapOnlyNestedJsonValue; +import org.jclouds.http.functions.UnwrapOnlyNestedJsonValueInSet; +import org.jclouds.rest.functions.MapHttp4xxCodesToExceptions; +import org.jclouds.rest.functions.ReturnEmptySetOnNotFoundOr404; +import org.jclouds.rest.functions.ReturnNullOnNotFoundOr404; +import org.jclouds.rest.functions.ReturnVoidOnNotFoundOr404; +import org.jclouds.rest.internal.RestAnnotationProcessor; +import org.testng.annotations.Test; + +import com.google.inject.TypeLiteral; + +/** + * Tests behavior of {@code NATAsyncClient} + * + * @author Adrian Cole + */ +// NOTE:without testName, this will not call @Before* and fail w/NPE during surefire +@Test(groups = "unit", testName = "NATAsyncClientTest") +public class NATAsyncClientTest extends BaseCloudStackAsyncClientTest { + public void testListIPForwardingRules() throws SecurityException, NoSuchMethodException, IOException { + Method method = NATAsyncClient.class.getMethod("listIPForwardingRules", ListIPForwardingRulesOptions[].class); + HttpRequest httpRequest = processor.createRequest(method); + + assertRequestLineEquals(httpRequest, + "GET http://localhost:8080/client/api?response=json&command=listIpForwardingRules HTTP/1.1"); + assertNonPayloadHeadersEqual(httpRequest, "Accept: application/json\n"); + assertPayloadEquals(httpRequest, null, null, false); + + assertResponseParserClassEquals(method, httpRequest, UnwrapOnlyNestedJsonValue.class); + assertSaxResponseParserClassEquals(method, null); + assertExceptionParserClassEquals(method, ReturnEmptySetOnNotFoundOr404.class); + + checkFilters(httpRequest); + + } + + public void testListIPForwardingRulesOptions() throws SecurityException, NoSuchMethodException, IOException { + Method method = NATAsyncClient.class.getMethod("listIPForwardingRules", ListIPForwardingRulesOptions[].class); + HttpRequest httpRequest = processor.createRequest(method, ListIPForwardingRulesOptions.Builder + .virtualMachineId(3)); + + assertRequestLineEquals( + httpRequest, + "GET http://localhost:8080/client/api?response=json&command=listIpForwardingRules&virtualmachineid=3 HTTP/1.1"); + assertNonPayloadHeadersEqual(httpRequest, "Accept: application/json\n"); + assertPayloadEquals(httpRequest, null, null, false); + + assertResponseParserClassEquals(method, httpRequest, UnwrapOnlyNestedJsonValue.class); + assertSaxResponseParserClassEquals(method, null); + assertExceptionParserClassEquals(method, ReturnEmptySetOnNotFoundOr404.class); + + checkFilters(httpRequest); + + } + + public void testGetIPForwardingRule() throws SecurityException, NoSuchMethodException, IOException { + Method method = NATAsyncClient.class.getMethod("getIPForwardingRule", long.class); + HttpRequest httpRequest = processor.createRequest(method, 5); + + assertRequestLineEquals(httpRequest, + "GET http://localhost:8080/client/api?response=json&command=listIpForwardingRules&id=5 HTTP/1.1"); + assertNonPayloadHeadersEqual(httpRequest, "Accept: application/json\n"); + assertPayloadEquals(httpRequest, null, null, false); + + assertResponseParserClassEquals(method, httpRequest, UnwrapOnlyNestedJsonValueInSet.class); + assertSaxResponseParserClassEquals(method, null); + assertExceptionParserClassEquals(method, ReturnNullOnNotFoundOr404.class); + + checkFilters(httpRequest); + + } + + public void testCreateIPForwardingRuleForVirtualMachine() throws SecurityException, NoSuchMethodException, + IOException { + Method method = NATAsyncClient.class.getMethod("createIPForwardingRuleForVirtualMachine", long.class, long.class, + String.class, int.class, CreateIPForwardingRuleOptions[].class); + HttpRequest httpRequest = processor.createRequest(method, 6, 7, "tcp", 22); + + assertRequestLineEquals(httpRequest, + "GET http://localhost:8080/client/api?response=json&command=createIpForwardingRule&virtualmachineid=6&protocol=tcp&ipaddressid=7&startport=22 HTTP/1.1"); + assertNonPayloadHeadersEqual(httpRequest, "Accept: application/json\n"); + assertPayloadEquals(httpRequest, null, null, false); + + assertResponseParserClassEquals(method, httpRequest, UnwrapOnlyJsonValue.class); + assertSaxResponseParserClassEquals(method, null); + assertExceptionParserClassEquals(method, MapHttp4xxCodesToExceptions.class); + + checkFilters(httpRequest); + + } + + public void testCreateIPForwardingRuleForVirtualMachineOptions() throws SecurityException, NoSuchMethodException, + IOException { + Method method = NATAsyncClient.class.getMethod("createIPForwardingRuleForVirtualMachine", long.class, long.class, + String.class, int.class, CreateIPForwardingRuleOptions[].class); + HttpRequest httpRequest = processor.createRequest(method, 6, 7, "tcp", 22, CreateIPForwardingRuleOptions.Builder + .endPort(22)); + + assertRequestLineEquals(httpRequest, + "GET http://localhost:8080/client/api?response=json&command=createIpForwardingRule&virtualmachineid=6&protocol=tcp&ipaddressid=7&startport=22&endport=22 HTTP/1.1"); + assertNonPayloadHeadersEqual(httpRequest, "Accept: application/json\n"); + assertPayloadEquals(httpRequest, null, null, false); + + assertResponseParserClassEquals(method, httpRequest, UnwrapOnlyJsonValue.class); + assertSaxResponseParserClassEquals(method, null); + assertExceptionParserClassEquals(method, MapHttp4xxCodesToExceptions.class); + + checkFilters(httpRequest); + + } + + public void testDeleteIPForwardingRule() throws SecurityException, NoSuchMethodException, IOException { + Method method = NATAsyncClient.class.getMethod("deleteIPForwardingRule", long.class); + HttpRequest httpRequest = processor.createRequest(method, 5); + + assertRequestLineEquals(httpRequest, + "GET http://localhost:8080/client/api?response=json&command=deleteIpForwardingRule&id=5 HTTP/1.1"); + assertNonPayloadHeadersEqual(httpRequest, ""); + assertPayloadEquals(httpRequest, null, null, false); + + assertResponseParserClassEquals(method, httpRequest, ReleasePayloadAndReturn.class); + assertSaxResponseParserClassEquals(method, null); + assertExceptionParserClassEquals(method, ReturnVoidOnNotFoundOr404.class); + + checkFilters(httpRequest); + + } + + @Override + protected TypeLiteral> createTypeLiteral() { + return new TypeLiteral>() { + }; + } +} diff --git a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/NATClientLiveTest.java b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/NATClientLiveTest.java new file mode 100644 index 0000000000..a0520d26eb --- /dev/null +++ b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/NATClientLiveTest.java @@ -0,0 +1,112 @@ +/** + * + * Copyright (C) 2010 Cloud Conscious, LLC. + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agred to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * Se the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.features; + +import static com.google.common.collect.Iterables.getOnlyElement; +import static org.testng.Assert.assertEquals; +import static org.testng.Assert.assertTrue; + +import java.util.Set; + +import org.jclouds.cloudstack.domain.AsyncCreateResponse; +import org.jclouds.cloudstack.domain.IPForwardingRule; +import org.jclouds.cloudstack.domain.PublicIPAddress; +import org.jclouds.cloudstack.domain.VirtualMachine; +import org.jclouds.cloudstack.options.ListIPForwardingRulesOptions; +import org.jclouds.net.IPSocket; +import org.testng.annotations.AfterGroups; +import org.testng.annotations.BeforeGroups; +import org.testng.annotations.Test; + +/** + * Tests behavior of {@code NATClientLiveTest} + * + * @author Adrian Cole + */ +@Test(groups = "live", sequential = true, testName = "NATClientLiveTest") +public class NATClientLiveTest extends BaseCloudStackClientLiveTest { + private PublicIPAddress ip = null; + private VirtualMachine vm; + private IPForwardingRule rule; + + @BeforeGroups(groups = "live") + public void setupClient() { + super.setupClient(); + prefix += "rule"; + ip = AddressClientLiveTest.createPublicIPAddress(client, jobComplete); + vm = VirtualMachineClientLiveTest.createVirtualMachine(client, jobComplete, virtualMachineRunning); + } + + public void testCreateIPForwardingRule() throws Exception { + // TODO check for 1-1 Nat feature + AsyncCreateResponse job = client.getNATClient().createIPForwardingRuleForVirtualMachine(vm.getId(), ip.getId(), + "tcp", 22); + assert jobComplete.apply(job.getJobId()); + rule = client.getNATClient().getIPForwardingRule(job.getId()); + assertEquals(rule.getIPAddressId(), ip.getId()); + assertEquals(rule.getVirtualMachineId(), vm.getId()); + assertEquals(rule.getPublicPort(), 22); + assertEquals(rule.getProtocol(), "tcp"); + checkRule(rule); + IPSocket socket = new IPSocket(ip.getIPAddress(), 22); + socketTester.apply(socket); + } + + @AfterGroups(groups = "live") + protected void tearDown() { + if (rule != null) { + client.getNATClient().deleteIPForwardingRule(rule.getId()); + } + if (ip != null) { + client.getAddressClient().disassociateIPAddress(ip.getId()); + } + if (vm != null) { + assert jobComplete.apply(client.getVirtualMachineClient().destroyVirtualMachine(vm.getId())); + } + super.tearDown(); + } + + public void testListIPForwardingRules() throws Exception { + Set response = client.getNATClient().listIPForwardingRules(); + assert null != response; + assertTrue(response.size() >= 0); + for (IPForwardingRule rule : response) { + IPForwardingRule newDetails = getOnlyElement(client.getNATClient().listIPForwardingRules( + ListIPForwardingRulesOptions.Builder.id(rule.getId()))); + assertEquals(rule.getId(), newDetails.getId()); + checkRule(rule); + } + } + + protected void checkRule(IPForwardingRule rule) { + assertEquals(rule.getId(), client.getNATClient().getIPForwardingRule(rule.getId()).getId()); + assert rule.getId() > 0 : rule; + assert rule.getIPAddress() != null : rule; + assert rule.getIPAddressId() > 0 : rule; + assert rule.getPrivatePort() > 0 : rule; + assert rule.getProtocol() != null : rule; + assert rule.getPublicPort() > 0 : rule; + assert rule.getState() != null : rule; + assert rule.getVirtualMachineDisplayName() != null : rule; + assert rule.getVirtualMachineId() > 0 : rule; + assert rule.getVirtualMachineName() != null : rule; + + } +} diff --git a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/VirtualMachineClientLiveTest.java b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/VirtualMachineClientLiveTest.java index 937a47f63a..a56b1d9876 100644 --- a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/VirtualMachineClientLiveTest.java +++ b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/features/VirtualMachineClientLiveTest.java @@ -26,8 +26,8 @@ import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertTrue; import java.util.Set; -import java.util.concurrent.TimeUnit; +import org.jclouds.cloudstack.CloudStackClient; import org.jclouds.cloudstack.domain.AsyncCreateResponse; import org.jclouds.cloudstack.domain.GuestIPType; import org.jclouds.cloudstack.domain.NIC; @@ -40,12 +40,8 @@ import org.jclouds.cloudstack.domain.VirtualMachine; import org.jclouds.cloudstack.domain.Zone; import org.jclouds.cloudstack.options.DeployVirtualMachineOptions; import org.jclouds.cloudstack.options.ListVirtualMachinesOptions; -import org.jclouds.cloudstack.predicates.JobComplete; -import org.jclouds.cloudstack.predicates.VirtualMachineDestroyed; -import org.jclouds.cloudstack.predicates.VirtualMachineRunning; import org.jclouds.predicates.RetryablePredicate; import org.testng.annotations.AfterGroups; -import org.testng.annotations.BeforeGroups; import org.testng.annotations.Test; import com.google.common.base.Predicate; @@ -60,19 +56,6 @@ import com.google.common.collect.Ordering; @Test(groups = "live", sequential = true, testName = "VirtualMachineClientLiveTest") public class VirtualMachineClientLiveTest extends BaseCloudStackClientLiveTest { private VirtualMachine vm = null; - private RetryablePredicate jobComplete; - private RetryablePredicate virtualMachineRunning; - private RetryablePredicate virtualMachineDestroyed; - - @BeforeGroups(groups = "live") - public void setupClient() { - super.setupClient(); - jobComplete = new RetryablePredicate(new JobComplete(client), 600, 5, TimeUnit.SECONDS); - virtualMachineRunning = new RetryablePredicate(new VirtualMachineRunning(client), 600, 5, - TimeUnit.SECONDS); - virtualMachineDestroyed = new RetryablePredicate(new VirtualMachineDestroyed(client), 600, 5, - TimeUnit.SECONDS); - } static final Ordering DEFAULT_SIZE_ORDERING = new Ordering() { public int compare(ServiceOffering left, ServiceOffering right) { @@ -81,7 +64,8 @@ public class VirtualMachineClientLiveTest extends BaseCloudStackClientLiveTest { } }; - public void testCreateDestroyVirtualMachine() throws Exception { + public static VirtualMachine createVirtualMachine(CloudStackClient client, RetryablePredicate jobComplete, + RetryablePredicate virtualMachineRunning) { final Zone zone = get(client.getZoneClient().listZones(), 0); long serviceOfferingId = DEFAULT_SIZE_ORDERING.min(client.getOfferingClient().listServiceOfferings()).getId(); @@ -121,11 +105,19 @@ public class VirtualMachineClientLiveTest extends BaseCloudStackClientLiveTest { AsyncCreateResponse job = client.getVirtualMachineClient().deployVirtualMachine(serviceOfferingId, templateId, zone.getId(), options); assert jobComplete.apply(job.getJobId()); - vm = client.getVirtualMachineClient().getVirtualMachine(job.getId()); + VirtualMachine vm = client.getVirtualMachineClient().getVirtualMachine(job.getId()); + if (vm.isPasswordEnabled()) + assert vm.getPassword() != null : vm; assert virtualMachineRunning.apply(vm); assertEquals(vm.getServiceOfferingId(), serviceOfferingId); assertEquals(vm.getTemplateId(), templateId); assertEquals(vm.getZoneId(), zone.getId()); + return vm; + } + + public void testCreateDestroyVirtualMachine() throws Exception { + vm = createVirtualMachine(client, jobComplete, virtualMachineRunning); + assertEquals(vm.getRootDeviceType(), "NetworkFilesystem"); checkVm(vm); } diff --git a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/options/CreateIPForwardingRuleOptionsTest.java b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/options/CreateIPForwardingRuleOptionsTest.java new file mode 100644 index 0000000000..1338859758 --- /dev/null +++ b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/options/CreateIPForwardingRuleOptionsTest.java @@ -0,0 +1,46 @@ +/** + * + * Copyright (C) 2010 Cloud Conscious, LLC. + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.options; + +import static org.jclouds.cloudstack.options.CreateIPForwardingRuleOptions.Builder.endPort; +import static org.testng.Assert.assertEquals; + +import org.testng.annotations.Test; + +import com.google.common.collect.ImmutableList; + +/** + * Tests behavior of {@code CreateIPForwardingRuleOptions} + * + * @author Adrian Cole + */ +@Test(groups = "unit") +public class CreateIPForwardingRuleOptionsTest { + + public void testNetworkId() { + CreateIPForwardingRuleOptions options = new CreateIPForwardingRuleOptions().endPort(6); + assertEquals(ImmutableList.of("6"), options.buildQueryParameters().get("endport")); + } + + public void testNetworkIdStatic() { + CreateIPForwardingRuleOptions options = endPort(6); + assertEquals(ImmutableList.of("6"), options.buildQueryParameters().get("endport")); + } +} diff --git a/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/options/ListIPForwardingRulesOptionsTest.java b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/options/ListIPForwardingRulesOptionsTest.java new file mode 100644 index 0000000000..76e37a2b43 --- /dev/null +++ b/sandbox-apis/cloudstack/src/test/java/org/jclouds/cloudstack/options/ListIPForwardingRulesOptionsTest.java @@ -0,0 +1,90 @@ +/** + * + * Copyright (C) 2010 Cloud Conscious, LLC. + * + * ==================================================================== + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ==================================================================== + */ + +package org.jclouds.cloudstack.options; + +import static org.jclouds.cloudstack.options.ListIPForwardingRulesOptions.Builder.account; +import static org.jclouds.cloudstack.options.ListIPForwardingRulesOptions.Builder.domainId; +import static org.jclouds.cloudstack.options.ListIPForwardingRulesOptions.Builder.id; +import static org.jclouds.cloudstack.options.ListIPForwardingRulesOptions.Builder.IPAddressId; +import static org.jclouds.cloudstack.options.ListIPForwardingRulesOptions.Builder.virtualMachineId; +import static org.testng.Assert.assertEquals; + +import org.testng.annotations.Test; + +import com.google.common.collect.ImmutableList; + +/** + * Tests behavior of {@code ListIPForwardingRulesOptions} + * + * @author Adrian Cole + */ +@Test(groups = "unit") +public class ListIPForwardingRulesOptionsTest { + + public void testId() { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions().id(6); + assertEquals(ImmutableList.of("6"), options.buildQueryParameters().get("id")); + } + + public void testIdStatic() { + ListIPForwardingRulesOptions options = id(6); + assertEquals(ImmutableList.of("6"), options.buildQueryParameters().get("id")); + } + + public void testAccount() { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions().account("account"); + assertEquals(ImmutableList.of("account"), options.buildQueryParameters().get("account")); + } + + public void testAccountStatic() { + ListIPForwardingRulesOptions options = account("account"); + assertEquals(ImmutableList.of("account"), options.buildQueryParameters().get("account")); + } + + public void testName() { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions().IPAddressId(9); + assertEquals(ImmutableList.of("9"), options.buildQueryParameters().get("ipaddressid")); + } + + public void testNameStatic() { + ListIPForwardingRulesOptions options = IPAddressId(9); + assertEquals(ImmutableList.of("9"), options.buildQueryParameters().get("ipaddressid")); + } + + public void testDomainId() { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions().domainId(6); + assertEquals(ImmutableList.of("6"), options.buildQueryParameters().get("domainid")); + } + + public void testDomainIdStatic() { + ListIPForwardingRulesOptions options = domainId(6); + assertEquals(ImmutableList.of("6"), options.buildQueryParameters().get("domainid")); + } + + public void testVirtualMachineId() { + ListIPForwardingRulesOptions options = new ListIPForwardingRulesOptions().virtualMachineId(6); + assertEquals(ImmutableList.of("6"), options.buildQueryParameters().get("virtualmachineid")); + } + + public void testVirtualMachineIdStatic() { + ListIPForwardingRulesOptions options = virtualMachineId(6); + assertEquals(ImmutableList.of("6"), options.buildQueryParameters().get("virtualmachineid")); + } +}