From 1340576311afe36f8b701bdffc693356b0637ca4 Mon Sep 17 00:00:00 2001 From: Martes G Wigglesworth Date: Tue, 5 Nov 2013 18:26:12 -0500 Subject: [PATCH] [JBIDE-15766]:Remove refresh of all IEnvironmentVariable on add/remove actions Please reference the following change log: Removed update calls from EnvironmentVariableResource.destroy, ApplicationResource.addEnvironmentVariable,ApplicationResource.addEnvironmentVariables,and ApplicationResource.removeEnvironmentVariable. Added ApplicationResource.removeEnvironmentVariable(IEnvironmentVariable) Renamed environmentVariableByName to environmentVariableMap Updated getOrLoadEnvironmentVariable to work check for emptiness of environmentVariableMap Updated loadEnvironmentVariables to work on environmentVariablesMap, and return it, in contrast to a locally-scoped version that did not persist. Corrected test failures due to omitted changes to instances methods for EnvironmentVariableResouce and ApplicationResource. Updated remove methods to use remove..(IEnvironmentVariable) and ApplicationResourceIntegrationTest to use Application.removeEnvironmentVariable(IEnvironmentVariable) in testing. Added integration test for removeEnvironmentVariable(IEnvironmentVariable) Updated ApplicationResource.addEnvironmentVariables(Map) to filter the incoming map key/value pairs if they are duplicate keys, without different values. This update should resolve unecessary update DTO requests being generated. (Rebased up to Nov 12 since the original PR got behind.) Corrected possible logical error that was accidentally included in addEnvinronmentVariables(Map), with the original PR. [if(testVar!=null)...else....] (Rebased again, to support merge with most recent version of upstream master: 13-NOV-2013) Corrected ApplicationResource.removeEnvironmentVariableByInstance(IEnvironmentVariable) and ApplicationResource.removeEnvironmentVariable(String) to correct failing test(s). --- .../com/openshift/client/IApplication.java | 62 ++++---- .../internal/client/ApplicationResource.java | 132 +++++++++++------- .../client/EnvironmentVariableResource.java | 23 ++- .../ApplicationResourceIntegrationTest.java | 66 +++++---- .../client/ApplicationResourceTest.java | 38 +++-- ...onmentVariableResourceIntegrationTest.java | 3 +- .../EnvironmentVariableResourceTest.java | 4 +- 7 files changed, 202 insertions(+), 126 deletions(-) diff --git a/src/main/java/com/openshift/client/IApplication.java b/src/main/java/com/openshift/client/IApplication.java index 57943cb8..ba3668ed 100755 --- a/src/main/java/com/openshift/client/IApplication.java +++ b/src/main/java/com/openshift/client/IApplication.java @@ -26,6 +26,7 @@ /** * @author André Dietisheim * @author Syed Iqbal + * @author Martes G Wigglesworth */ public interface IApplication extends IOpenShiftResource { @@ -423,7 +424,7 @@ public IEmbeddedCartridge getEmbeddedCartridge(IEmbeddableCartridge cartridge) /** * Retrieves the map of environment variables * - * @return the list of environment variables + * @return the Map of environment variables * @throws OpenShiftSSHOperationException */ public Map getEnvironmentVariables() throws OpenShiftSSHOperationException; @@ -431,30 +432,26 @@ public IEmbeddedCartridge getEmbeddedCartridge(IEmbeddableCartridge cartridge) /** * Checks if the environment variable is present in the application. * - * @param name - * Name of the environment variable - * @return + * @param name Name of the environment variable + * @return true if the current instance has IEnvironmentVariables to return
+ * false if the current instance has no IEnvironmentVariables to return * @throws OpenShiftSSHOperationException */ public boolean hasEnvironmentVariable(String name) throws OpenShiftException; /** - * Adds an environment variable to this application. If the environment - * variable exists already, then an OpenShift exception is thrown. + * Adds an environment variable to this application. * - * @param name - * name of the variable to add - * @param value - * value of the new variable - * @throws OpenShiftSSHOperationException + * @param name key associated with the variable to add + * @param value value of the new variable + * @throws OpenShiftSSHOperationException - if the variable already exists */ public IEnvironmentVariable addEnvironmentVariable(String name, String value) throws OpenShiftException; /** * Adds a map of environment variables to the application * - * @param environmentVariables - * map of environment variables + * @param environmentVariables Map of environment variables * @throws OpenShiftSSHOperationException */ public Map addEnvironmentVariables(Map environmentVariables) @@ -463,42 +460,47 @@ public Map addEnvironmentVariables(Maptrue if this application can list its environment - * variables. Returns false if it cant. Internally this - * translates to the presence of the link to list environment variables. + * Used to determine if environment variables exist and are available to be retrieved * - * @return true if this application can list its envirnoment variables + * @return Returns true if this application can list its environment variables.
+ * Returns false if it cannot. Internally this translates to the presence of the link to list environment variables. * - * @see #getEnvironmentVariables() + * @see #getEnvironmentVariablesMap() * @see #getEnvironmentVariable(String) * @see ApplicationResource#LINK_LIST_ENVIRONMENT_VARIABLES */ public boolean canGetEnvironmentVariables(); /** - * Returns true if this application can update (set or unset) - * its environment variables. Returns false if it cannot. - * Internally this translates to the presence of the link to set and unset - * environment variables. + * Used to determine if the current instance is able to update environment variables. * - * @return true if this application can set/unset its environment variables + * @return Returns true if this application can augment its environment variables.
+ * Returns false if it cannot.
* * @see #addEnvironmentVariable(String, String) * @see #addEnvironmentVariables(Map) diff --git a/src/main/java/com/openshift/internal/client/ApplicationResource.java b/src/main/java/com/openshift/internal/client/ApplicationResource.java index ed89cb90..cdc7b7fd 100755 --- a/src/main/java/com/openshift/internal/client/ApplicationResource.java +++ b/src/main/java/com/openshift/internal/client/ApplicationResource.java @@ -67,10 +67,12 @@ import com.openshift.internal.client.utils.StringUtils; /** - * The Class Application. + * The ApplicationResource object is an implementation of com.openshift.client.IApplication, and provides + * a runtime model for the real application that resides on the OpenShift platform being accessed. * * @author André Dietisheim * @author Syed Iqbal + * @author Martes G Wigglesworth */ public class ApplicationResource extends AbstractOpenShiftResource implements IApplication { @@ -149,7 +151,7 @@ public class ApplicationResource extends AbstractOpenShiftResource implements IA /** * The environment variables for this application */ - private Map environmentVariableByName; + private Map environmentVariablesMap; protected ApplicationResource(ApplicationResourceDTO dto, DomainResource domain) { @@ -203,6 +205,7 @@ protected ApplicationResource(final String name, final String uuid, final String this.domain = domain; this.aliases = aliases; updateCartridges(cartridgesByName); + environmentVariablesMap = new HashMap(); } public String getName() { @@ -611,11 +614,11 @@ public Map getEnvironmentVariables() throws OpenSh return Collections.unmodifiableMap(new LinkedHashMap(getOrLoadEnvironmentVariables())); } - protected Map getOrLoadEnvironmentVariables() throws OpenShiftException { - if (environmentVariableByName == null) { - this.environmentVariableByName = loadEnvironmentVariables(); - } - return environmentVariableByName; + + protected Map getOrLoadEnvironmentVariables() throws OpenShiftException { + if(environmentVariablesMap.isEmpty()) + environmentVariablesMap = loadEnvironmentVariables(); + return environmentVariablesMap; } private Map loadEnvironmentVariables() throws OpenShiftException { @@ -624,13 +627,14 @@ private Map loadEnvironmentVariables() throws Open return new LinkedHashMap(); } - Map environmentVariablesByName = new LinkedHashMap(); for (EnvironmentVariableResourceDTO environmentVariableResourceDTO : environmentVariableDTOs) { final IEnvironmentVariable environmentVariable = new EnvironmentVariableResource(environmentVariableResourceDTO, this); - environmentVariablesByName.put(environmentVariable.getName(), environmentVariable); + + environmentVariablesMap.put(environmentVariable.getName(),environmentVariable); + } - return environmentVariablesByName; + return environmentVariablesMap; } @Override @@ -643,42 +647,67 @@ public IEnvironmentVariable addEnvironmentVariable(String name, String value) th } if (hasEnvironmentVariable(name)) { throw new OpenShiftException("Environment variable with name \"{0}\" already exists.", name); - } - + } + EnvironmentVariableResourceDTO environmentVariableResourceDTO = - new AddEnvironmentVariableRequest().execute(name, value); + new AddEnvironmentVariableRequest().execute(name, value); IEnvironmentVariable environmentVariable = new EnvironmentVariableResource(environmentVariableResourceDTO, this); - updateEnvironmentVariables(); + + environmentVariablesMap.put(environmentVariable.getName(), environmentVariable); + return environmentVariable; } @Override - public Map addEnvironmentVariables(Map environmentVariablesMap) + public Map addEnvironmentVariables(Map environmentVariables) throws OpenShiftException { - - List environmentVariableResourceDTOs = new AddEnvironmentVariablesRequest() - .execute(environmentVariablesMap); - Map environmentVariables = new HashMap(); + + MapvariablesCandidateMap = new HashMap(); + for(String varCandidateName:environmentVariables.keySet()){ + IEnvironmentVariable tempVar = environmentVariablesMap.get(varCandidateName); + if(tempVar != null) + { if(tempVar.getValue() == environmentVariables.get(varCandidateName)) + variablesCandidateMap.put(varCandidateName,environmentVariables.get(varCandidateName)); + } + else + variablesCandidateMap.put(varCandidateName, environmentVariables.get(varCandidateName)); + } + List environmentVariableResourceDTOs = new AddEnvironmentVariablesRequest() + .execute(variablesCandidateMap); + for (EnvironmentVariableResourceDTO dto : environmentVariableResourceDTOs) { IEnvironmentVariable environmentVariable = new EnvironmentVariableResource(dto, this); - environmentVariables.put(environmentVariable.getName(), environmentVariable); + environmentVariablesMap.put(environmentVariable.getName(), environmentVariable); } - - updateEnvironmentVariables(); - return environmentVariables; + + return environmentVariablesMap; } - + /* + * (non-Javadoc) + * @see com.openshift.client.IApplication#removeEnvironmentVariable(java.lang.String) + */ @Override - public void removeEnvironmentVariable(String name) { - IEnvironmentVariable environmentVariable = getEnvironmentVariable(name); - if (environmentVariable == null) { - return; - } - - environmentVariable.destroy(); - updateEnvironmentVariables(); + public void removeEnvironmentVariable(String targetName) { + removeEnvironmentVariable(getEnvironmentVariable(targetName)); } + /* (non-Javadoc) + * @see com.openshift.client.IApplication#removeEnvironmentVariable(com.openshift.client.IEnvironmentVariable) + */ + @Override + public void removeEnvironmentVariable(IEnvironmentVariable environmentVariable){ + if(getEnvironmentVariable(environmentVariable.getName()) == null) + throw new OpenShiftException("IEnvironmentVariable with supplied name does not exist."); + environmentVariable.destroy(); + environmentVariablesMap.remove(environmentVariable.getName()); + + } + + + /* + * (non-Javadoc) + * @see com.openshift.client.IApplication#hasEnvironmentVariable(java.lang.String) + */ @Override public boolean hasEnvironmentVariable(String name) throws OpenShiftException { if (StringUtils.isEmpty(name)) { @@ -689,17 +718,20 @@ public boolean hasEnvironmentVariable(String name) throws OpenShiftException { } protected void updateEnvironmentVariables() throws OpenShiftException { - if (!canGetEnvironmentVariables()) { + if (!canGetEnvironmentVariables()) return; + else + { + environmentVariablesMap.clear(); + environmentVariablesMap = loadEnvironmentVariables(); } - if (environmentVariableByName == null) { - environmentVariableByName = loadEnvironmentVariables(); - } else { - environmentVariableByName.clear(); - environmentVariableByName.putAll(loadEnvironmentVariables()); - } + } + /* + * (non-Javadoc) + * @see com.openshift.client.IApplication#getEnvironmentVariable(java.lang.String) + */ @Override public IEnvironmentVariable getEnvironmentVariable(String name) { return getEnvironmentVariables().get(name); @@ -714,6 +746,10 @@ public boolean canGetEnvironmentVariables() { } } + /* + * (non-Javadoc) + * @see com.openshift.client.IApplication#canUpdateEnvironmentVariables() + */ @Override public boolean canUpdateEnvironmentVariables() { try { @@ -820,9 +856,11 @@ public List startPortForwarding() throws OpenShiftSS try { port.start(session); } catch (OpenShiftSSHOperationException oss) { - // ignore for now - // FIXME: should store this error on the forward to let user - // know why it could not start/stop + /* + * ignore for now + * FIXME: should store this error on the forward to let user + * know why it could not start/stop + */ } } return ports; @@ -833,9 +871,10 @@ public List stopPortForwarding() throws OpenShiftSSH try { port.stop(session); } catch (OpenShiftSSHOperationException oss) { - // ignore for now - // should store this error on the forward to let user know why - // it could not start/stop + /* ignore for now + * should store this error on the forward to let user know why + * it could not start/stop + */ } } // make sure port forwarding is stopped by closing session... @@ -1094,5 +1133,4 @@ protected List execute(Map envir } } - -} + } diff --git a/src/main/java/com/openshift/internal/client/EnvironmentVariableResource.java b/src/main/java/com/openshift/internal/client/EnvironmentVariableResource.java index 43765fe8..2e6d24e3 100644 --- a/src/main/java/com/openshift/internal/client/EnvironmentVariableResource.java +++ b/src/main/java/com/openshift/internal/client/EnvironmentVariableResource.java @@ -61,14 +61,22 @@ public String getValue() { } @Override - public void update(String value) throws OpenShiftException { - if (value == null) { + public void update(String newValue) throws OpenShiftException { + if (newValue == null) { throw new OpenShiftException("Value for environment variable \"{0}\" not given.", name); } EnvironmentVariableResourceDTO environmentVariableResourceDTO = - new UpdateEnvironmentVariableRequest().execute(value); + new UpdateEnvironmentVariableRequest().execute(newValue); updateEnvironmentVariable(environmentVariableResourceDTO); + /* + * This should be done in the IApplication, to break up this dependency + * on the entity, i.e. IEnvironmentVariable, on something that is + * outside of itself, such as the implementation of IApplication. + * @author Martes G Wigglesworth + */ application.updateEnvironmentVariables(); + + } private void updateEnvironmentVariable(EnvironmentVariableResourceDTO dto) { @@ -81,7 +89,7 @@ private void updateEnvironmentVariable(EnvironmentVariableResourceDTO dto) { @Override public void destroy() throws OpenShiftException { new DeleteEnvironmentVariableRequest().execute(); - application.updateEnvironmentVariables(); + } @Override @@ -118,5 +126,10 @@ protected DeleteEnvironmentVariableRequest() { public IApplication getApplication() { return application; } - + + public String toString(){ + return new String( + "Name:"+this.name+",Value:"+value + ); + } } diff --git a/src/test/java/com/openshift/internal/client/ApplicationResourceIntegrationTest.java b/src/test/java/com/openshift/internal/client/ApplicationResourceIntegrationTest.java index 18e0bc40..8aa9a278 100755 --- a/src/test/java/com/openshift/internal/client/ApplicationResourceIntegrationTest.java +++ b/src/test/java/com/openshift/internal/client/ApplicationResourceIntegrationTest.java @@ -18,6 +18,7 @@ import java.net.MalformedURLException; import java.util.Collection; import java.util.HashMap; +import java.util.List; import java.util.Map; import org.junit.Before; @@ -43,6 +44,7 @@ /** * @author André Dietisheim * @author Syed Iqbal + * @author Martes G Wigglesworth */ public class ApplicationResourceIntegrationTest { @@ -336,7 +338,7 @@ public void shouldGetEnvironmentVariableByName() throws Throwable { } @Test - public void shouldDestroyEnvironmentVariable() throws Throwable{ + public void shouldRemoveEnvironmentVariable() throws Throwable{ //pre-conditions IApplication application = ApplicationTestUtils.getOrCreateApplication(domain); ApplicationTestUtils.destroyAllEnvironmentVariables(application); @@ -344,15 +346,15 @@ public void shouldDestroyEnvironmentVariable() throws Throwable{ assertThat(application.getEnvironmentVariables().size()).isEqualTo(1); //operation - environmentVariable.destroy(); + application.removeEnvironmentVariable(environmentVariable.getName()); //verification assertThat(application.getEnvironmentVariables().size()).isEqualTo(0); assertThat(application.hasEnvironmentVariable("FOOBAR")).isFalse(); } - + @Test - public void shouldRemoveEnvironmentVariable() throws Throwable{ + public void shouldRemoveEnvironmentVariableByInstance() throws Throwable{ //pre-conditions IApplication application = ApplicationTestUtils.getOrCreateApplication(domain); ApplicationTestUtils.destroyAllEnvironmentVariables(application); @@ -360,7 +362,7 @@ public void shouldRemoveEnvironmentVariable() throws Throwable{ assertThat(application.getEnvironmentVariables().size()).isEqualTo(1); //operation - application.removeEnvironmentVariable(environmentVariable.getName()); + application.removeEnvironmentVariable(environmentVariable); //verification assertThat(application.getEnvironmentVariables().size()).isEqualTo(0); @@ -383,37 +385,39 @@ public void shouldNotAddExistingEnvironmentVariableToApplication() throws Throwa } } + @Test - public void shouldListAllEnvironmentVariables() throws Throwable { - // preconditions - ApplicationTestUtils.silentlyDestroyAllApplications(domain); - IApplication application = ApplicationTestUtils.getOrCreateApplication(domain); - Map environmentVariableMap = new HashMap(); - environmentVariableMap.put("X_NAME", "X_VALUE"); - environmentVariableMap.put("Y_NAME", "Y_VALUE"); - environmentVariableMap.put("Z_NAME", "Z_VALUE"); - application.addEnvironmentVariables(environmentVariableMap); + public void shouldGetMapOfAllEnvironmentVariables() throws Throwable { + // preconditions + ApplicationTestUtils.silentlyDestroyAllApplications(domain); + IApplication application = ApplicationTestUtils.getOrCreateApplication(domain); + Map environmentVariableMap = new HashMap(); + environmentVariableMap.put("X_NAME", "X_VALUE"); + environmentVariableMap.put("Y_NAME", "Y_VALUE"); + environmentVariableMap.put("Z_NAME", "Z_VALUE"); + application.addEnvironmentVariables(environmentVariableMap); + + // operation + Map environmentVariables = application.getEnvironmentVariables(); - // operation - Map environmentVariables = application.getEnvironmentVariables(); - - // verifications - assertThat(environmentVariables).hasSize(3); - } + // verifications + assertThat(environmentVariables).hasSize(3); + } + - @Test - public void shouldLoadEmptyListOfEnvironmentVariables() throws Throwable{ - //precondition - ApplicationTestUtils.silentlyDestroyAllApplications(domain); - IApplication application = ApplicationTestUtils.getOrCreateApplication(domain); + @Test + public void shouldLoadEmptyMapOfEnvironmentVariables() throws Throwable{ + //precondition + ApplicationTestUtils.silentlyDestroyAllApplications(domain); + IApplication application = ApplicationTestUtils.getOrCreateApplication(domain); - //operation - Map environmentVariables = application.getEnvironmentVariables(); + //operation + Map environmentVariables = application.getEnvironmentVariables(); + + //verifications + assertThat(environmentVariables).isEmpty(); + } - //verifications - assertThat(environmentVariables).isEmpty(); - } - @Test public void shouldCanGetCanUpdateEnvironmentVariables() throws Throwable { // pre-conditions diff --git a/src/test/java/com/openshift/internal/client/ApplicationResourceTest.java b/src/test/java/com/openshift/internal/client/ApplicationResourceTest.java index 1b953cbf..8f71f631 100644 --- a/src/test/java/com/openshift/internal/client/ApplicationResourceTest.java +++ b/src/test/java/com/openshift/internal/client/ApplicationResourceTest.java @@ -564,7 +564,7 @@ public void shouldGetForwardablePorts() throws Throwable { } @Test - public void shouldCanListEnvironmentVariables() throws Throwable { + public void shouldCanGetEnvironmentVariables() throws Throwable { // pre-conditions mockDirector .mockAddEnvironmentVariable("foobarz", "springeap6", @@ -639,11 +639,9 @@ public void shouldRefreshEnvironmentVariables() throws Throwable { .mockGetEnvironmentVariables("foobarz", "springeap6", GET_1_ENVIRONMENT_VARIABLES_FOOBARZ_SPRINGEAP6, GET_2_ENVIRONMENT_VARIABLES_FOOBARZ_SPRINGEAP6); final IApplication app = domain.getApplicationByName("springeap6"); - Map environmentVariables = app.getEnvironmentVariables(); - assertThat(environmentVariables).hasSize(1); + assertThat(app.getEnvironmentVariables()).hasSize(1); // operation app.refresh(); - // verification assertThat(app.getEnvironmentVariables()).hasSize(2); } @@ -685,25 +683,42 @@ public void shouldNotAddExistingEnvironmentVariable() throws Throwable { } @Test - public void shouldRemoveEnvironmentVariable() throws Throwable { + public void shouldRemoveEnvironmentVariableByName() throws Throwable { // precondition mockDirector.mockGetEnvironmentVariables("foobarz", "springeap6", GET_1_ENVIRONMENT_VARIABLES_FOOBARZ_SPRINGEAP6, GET_0_ENVIRONMENT_VARIABLES_FOOBARZ_SPRINGEAP6); final IApplication app = domain.getApplicationByName("springeap6"); assertThat(app.getEnvironmentVariables()).hasSize(1); - IEnvironmentVariable existingEnvironmentVariable = app.getEnvironmentVariables().get("FOO"); - assertThat(existingEnvironmentVariable.getName()).isEqualTo("FOO"); + assertThat(app.getEnvironmentVariables().get("FOO").getName() == "FOO"); // operation - existingEnvironmentVariable.destroy(); + app.removeEnvironmentVariable("FOO"); // verification assertThat(app.getEnvironmentVariables()).hasSize(0); assertThat(app.hasEnvironmentVariable("FOO")).isFalse(); } - + @Test - public void shouldListAllEnvironmentVariablesFromApplication() throws Throwable { + public void shouldRemoveEnvironmentVariable() throws Throwable { + // precondition + mockDirector.mockGetEnvironmentVariables("foobarz", "springeap6", + GET_1_ENVIRONMENT_VARIABLES_FOOBARZ_SPRINGEAP6, GET_0_ENVIRONMENT_VARIABLES_FOOBARZ_SPRINGEAP6); + final IApplication app = domain.getApplicationByName("springeap6"); + assertThat(app.getEnvironmentVariables()).hasSize(1); + IEnvironmentVariable environmentVariable = app.getEnvironmentVariables().get("FOO"); + assertThat(environmentVariable.getName()).isEqualTo("FOO"); + + // operation + app.removeEnvironmentVariable(environmentVariable); + + // verification + assertThat(app.getEnvironmentVariables()).hasSize(0); + assertThat(app.hasEnvironmentVariable("FOO")).isFalse(); + } + + @Test + public void shouldGetMapOfAllEnvironmentVariablesFromApplication() throws Throwable { // preconditions mockDirector.mockGetEnvironmentVariables("foobarz", "springeap6", GET_4_ENVIRONMENT_VARIABLES_FOOBARZ_SPRINGEAP6); @@ -719,7 +734,7 @@ public void shouldListAllEnvironmentVariablesFromApplication() throws Throwable } @Test - public void shouldLoadEmptyListOfEnvironmentVariables() throws Throwable { + public void shouldLoadEmptyMapOfEnvironmentVariables() throws Throwable { // precondition mockDirector .mockGetEnvironmentVariables("foobarz", "springeap6", GET_0_ENVIRONMENT_VARIABLES_FOOBARZ_SPRINGEAP6); @@ -756,4 +771,5 @@ public void shouldEqualApplication() throws Throwable { assertTrue(domain != this.domain); } + } diff --git a/src/test/java/com/openshift/internal/client/EnvironmentVariableResourceIntegrationTest.java b/src/test/java/com/openshift/internal/client/EnvironmentVariableResourceIntegrationTest.java index 536dc9ea..ff2246ed 100644 --- a/src/test/java/com/openshift/internal/client/EnvironmentVariableResourceIntegrationTest.java +++ b/src/test/java/com/openshift/internal/client/EnvironmentVariableResourceIntegrationTest.java @@ -70,7 +70,8 @@ public void shouldDeleteEnvironmentVariableValue() throws Throwable { application.addEnvironmentVariable("Z_NAME", "Z_VALUE"); // operation IEnvironmentVariable zEnvironmentVariable = application.getEnvironmentVariable("Z_NAME"); - zEnvironmentVariable.destroy(); + application.removeEnvironmentVariable(zEnvironmentVariable); + //application.refresh(); zEnvironmentVariable = application.getEnvironmentVariable("Z_NAME"); assertThat(zEnvironmentVariable).isNull(); } diff --git a/src/test/java/com/openshift/internal/client/EnvironmentVariableResourceTest.java b/src/test/java/com/openshift/internal/client/EnvironmentVariableResourceTest.java index 73111b71..62916f89 100644 --- a/src/test/java/com/openshift/internal/client/EnvironmentVariableResourceTest.java +++ b/src/test/java/com/openshift/internal/client/EnvironmentVariableResourceTest.java @@ -26,6 +26,7 @@ /** * @author Syed Iqbal + * @author Martes G Wigglesworth */ public class EnvironmentVariableResourceTest { @@ -70,7 +71,8 @@ public void shouldDeleteEnvironmentVariable() throws Throwable{ //operation IEnvironmentVariable environmentVariable = application.getEnvironmentVariable("FOO"); assertThat(environmentVariable).isNotNull(); - environmentVariable.destroy(); + application.removeEnvironmentVariable(environmentVariable); + application.refresh(); environmentVariable = application.getEnvironmentVariable("FOO"); assertThat(environmentVariable).isNull(); }