package org.opennaas.core.resources.tests;
/*
* #%L
* OpenNaaS :: Core :: Resources
* %%
* Copyright (C) 2007 - 2014 Fundació Privada i2CAT, Internet i Innovació a Catalunya
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Lesser Public License for more details.
*
* You should have received a copy of the GNU General Lesser Public
* License along with this program. If not, see
* <http://www.gnu.org/licenses/lgpl-3.0.html>.
* #L%
*/
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import java.util.ArrayList;
import java.util.List;
import junit.framework.Assert;
import org.junit.Test;
import org.opennaas.core.resources.CorruptStateException;
import org.opennaas.core.resources.ILifecycle.State;
import org.opennaas.core.resources.IResourceBootstrapper;
import org.opennaas.core.resources.IncorrectLifecycleStateException;
import org.opennaas.core.resources.Resource;
import org.opennaas.core.resources.ResourceException;
import org.opennaas.core.resources.capability.ICapability;
import org.opennaas.core.resources.capability.ICapabilityLifecycle;
public class ResourceLifeCycleTest {
Resource resource;
// methods
// resource.initialize();
// resource.activate();
// resource.shutdown();
// resource.deactivate();
@Test
public void expectedLifeCycleTest() {
resource = new Resource();// STATE INSTANTIATED
try {
resource.initialize();
Assert.assertEquals(resource.getState(), State.INITIALIZED);
resource.activate();
Assert.assertEquals(resource.getState(), State.ACTIVE);
resource.deactivate();
Assert.assertEquals(resource.getState(), State.INITIALIZED);
resource.shutdown();
Assert.assertEquals(resource.getState(), State.SHUTDOWN);
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getMessage());
} catch (ResourceException e) {
Assert.fail(e.getMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getMessage());
}
}
@Test
public void initializedStateTest() {
resource = new Resource();// STATE INSTANTIATED
resource.setState(State.INITIALIZED);
boolean a = false, b = false;
try {
try {
resource.initialize();
} catch (IncorrectLifecycleStateException e1) {
a = true;
}
try {
resource.deactivate();
} catch (IncorrectLifecycleStateException e) {
b = true;
}
Assert.assertEquals(resource.getState(), State.INITIALIZED);
try {
resource.activate();
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getMessage());
}
Assert.assertEquals(resource.getState(), State.ACTIVE);
resource.setState(State.INITIALIZED);
try {
resource.shutdown();
} catch (IncorrectLifecycleStateException e1) {
Assert.fail(e1.getMessage());
}
Assert.assertEquals(resource.getState(), State.SHUTDOWN);
} catch (ResourceException e) {
Assert.fail(e.getMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getMessage());
}
Assert.assertTrue(a);
Assert.assertTrue(b);
}
@Test
public void activeStateTest() {
resource = new Resource();// STATE INSTANTIATED
resource.setState(State.ACTIVE);
boolean a = false, b = false, c = false;
try {
try {
resource.initialize();
} catch (IncorrectLifecycleStateException e1) {
a = true;
}
try {
resource.activate();
} catch (IncorrectLifecycleStateException e) {
b = true;
}
try {
resource.shutdown();
} catch (IncorrectLifecycleStateException e1) {
c = true;
}
Assert.assertEquals(resource.getState(), State.ACTIVE);
try {
resource.deactivate();
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getMessage());
}
Assert.assertEquals(resource.getState(), State.INITIALIZED);
} catch (ResourceException e) {
Assert.fail(e.getMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getMessage());
}
Assert.assertTrue(a);
Assert.assertTrue(b);
Assert.assertTrue(c);
}
@Test
public void instantiatedStateTest() {
resource = new Resource();// STATE INSTANTIATED
boolean a = false, b = false, c = false;
try {
try {
resource.deactivate();
} catch (IncorrectLifecycleStateException e1) {
a = true;
}
try {
resource.activate();
} catch (IncorrectLifecycleStateException e) {
b = true;
}
try {
resource.shutdown();
} catch (IncorrectLifecycleStateException e1) {
c = true;
}
Assert.assertEquals(resource.getState(), State.INSTANTIATED);
try {
resource.initialize();
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getMessage());
}
Assert.assertEquals(resource.getState(), State.INITIALIZED);
} catch (ResourceException e) {
Assert.fail(e.getMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getMessage());
}
Assert.assertTrue(a);
Assert.assertTrue(b);
Assert.assertTrue(c);
}
@Test
public void activateResourceTest() {
try {
Resource resource = new Resource();
resource.initialize();
ICapabilityLifecycle mockCapability = createMock(ICapabilityLifecycle.class);
mockCapability.initialize(); // expect capability to be initialized and activated
mockCapability.activate();
replay(mockCapability);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability);
resource.setCapabilities(capabilities);
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.bootstrap(resource); // expect a call to bootstrap
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
resource.setState(State.INITIALIZED);
resource.activate();
verify(mockBootstrapper); // verify bootstrap() has been called
verify(mockCapability); // verify capability initialize() and activate() have been called
Assert.assertTrue(resource.getState().equals(State.ACTIVE));
} catch (ResourceException e) {
Assert.fail(e.getLocalizedMessage());
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getLocalizedMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getLocalizedMessage());
}
}
@Test
public void deactivateResourceTest() {
try {
Resource resource = new Resource();
resource.initialize();
ICapabilityLifecycle mockCapability = createMock(ICapabilityLifecycle.class);
mockCapability.deactivate(); // expected
mockCapability.shutdown();
replay(mockCapability);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability);
resource.setCapabilities(capabilities);
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.revertBootstrap(resource); // expected
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
resource.setState(State.ACTIVE);
resource.deactivate();
verify(mockBootstrapper); // verify mockBootsrapper expectations
verify(mockCapability); // verify mockCapability expectations
Assert.assertTrue(resource.getState().equals(State.INITIALIZED));
} catch (ResourceException e) {
Assert.fail(e.getLocalizedMessage());
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getLocalizedMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getLocalizedMessage());
}
}
@Test
public void activateResourceRollbackTest1() {
try {
Resource resource = new Resource();
resource.initialize();
ICapabilityLifecycle mockCapability = createMock(ICapabilityLifecycle.class);
mockCapability.getState();
expectLastCall().andReturn(ICapabilityLifecycle.State.INITIALIZED).anyTimes();
mockCapability.initialize();
expectLastCall().atLeastOnce();
mockCapability.activate();
expectLastCall().andThrow(new ResourceException());
mockCapability.deactivate(); // @ rollback
expectLastCall().anyTimes();
mockCapability.shutdown();
expectLastCall().anyTimes();
replay(mockCapability);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability);
resource.setCapabilities(capabilities);
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.bootstrap(resource); // expect a call to bootstrap
expectLastCall().anyTimes(); // it may not happen
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
resource.setState(State.INITIALIZED);
boolean hasThrown = false;
try {
resource.activate();
} catch (ResourceException e) {
hasThrown = true;
}
Assert.assertTrue(hasThrown);
verify(mockBootstrapper); // verify bootstrap() has been called
verify(mockCapability); // verify capability initialize() and activate() have been called
Assert.assertTrue(resource.getState().equals(State.INITIALIZED));
} catch (ResourceException e) {
Assert.fail(e.getLocalizedMessage());
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getLocalizedMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getLocalizedMessage());
}
}
@Test
public void activateResourceRollbackTest2() {
try {
Resource resource = new Resource();
resource.initialize();
ICapabilityLifecycle mockCapability = createMock(ICapabilityLifecycle.class);
mockCapability.getState();
expectLastCall().andReturn(ICapabilityLifecycle.State.INITIALIZED).anyTimes();
mockCapability.initialize(); // it may not happen if bootstrap fails
expectLastCall().anyTimes();
mockCapability.activate();
expectLastCall().anyTimes();
mockCapability.deactivate(); // @ rollback
expectLastCall().anyTimes();
mockCapability.shutdown();
expectLastCall().anyTimes();
replay(mockCapability);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability);
resource.setCapabilities(capabilities);
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.bootstrap(resource);
expectLastCall().andThrow(new ResourceException());
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
resource.setState(State.INITIALIZED);
boolean hasThrown = false;
try {
resource.activate();
} catch (ResourceException e) {
hasThrown = true;
}
Assert.assertTrue(hasThrown);
verify(mockBootstrapper);
verify(mockCapability);
Assert.assertTrue(resource.getState().equals(State.INITIALIZED));
} catch (ResourceException e) {
Assert.fail(e.getLocalizedMessage());
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getLocalizedMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getLocalizedMessage());
}
}
@Test
public void deactivateResourceRollbackTest1() {
try {
Resource resource = new Resource();
resource.initialize();
ICapabilityLifecycle mockCapability = createMock(ICapabilityLifecycle.class);
mockCapability.getState();
expectLastCall().andReturn(ICapabilityLifecycle.State.INITIALIZED).anyTimes();
mockCapability.deactivate();
expectLastCall().andThrow(new ResourceException());
mockCapability.shutdown();
expectLastCall().anyTimes();
mockCapability.initialize(); // @ rollback
expectLastCall().anyTimes();
mockCapability.activate();
expectLastCall().anyTimes();
replay(mockCapability);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability);
resource.setCapabilities(capabilities);
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.revertBootstrap(resource); // expect a call to bootstrap
expectLastCall().anyTimes(); // it may not happen if deactivate fails first
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
resource.setState(State.ACTIVE);
boolean hasThrown = false;
try {
resource.deactivate();
} catch (CorruptStateException e) { // CORRUPT! capability.deactivate() fails after revertBootstrap() is executed -> corrupt state
hasThrown = true;
}
Assert.assertTrue(hasThrown);
verify(mockBootstrapper);
verify(mockCapability);
Assert.assertTrue(resource.getState().equals(State.ERROR));
} catch (ResourceException e) {
Assert.fail(e.getLocalizedMessage());
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getLocalizedMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getLocalizedMessage());
}
}
@Test
public void deactivateResourceRollbackTest2() {
try {
Resource resource = new Resource();
resource.initialize();
ICapabilityLifecycle mockCapability = createMock(ICapabilityLifecycle.class);
mockCapability.getState();
expectLastCall().andReturn(ICapabilityLifecycle.State.INITIALIZED).anyTimes();
mockCapability.deactivate(); // they may not happen if revertBootstrap fails first
expectLastCall().anyTimes();
mockCapability.shutdown();
expectLastCall().anyTimes();
mockCapability.initialize(); // @ rollback
expectLastCall().anyTimes();
mockCapability.activate();
expectLastCall().anyTimes();
replay(mockCapability);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability);
resource.setCapabilities(capabilities);
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.revertBootstrap(resource);
expectLastCall().andThrow(new ResourceException());
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
resource.setState(State.ACTIVE);
boolean hasThrown = false;
try {
resource.deactivate();
} catch (ResourceException e) {
hasThrown = true;
}
Assert.assertTrue(hasThrown);
verify(mockBootstrapper); // verify bootstrap() has been called
verify(mockCapability); // verify capability initialize() and activate() have been called
Assert.assertTrue(resource.getState().equals(State.ACTIVE));
} catch (ResourceException e) {
Assert.fail(e.getLocalizedMessage());
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getLocalizedMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getLocalizedMessage());
}
}
// TODO test activate && deactivate corrupt
@Test
public void activateResourceRollbackCorruptTest() {
try {
Resource resource = new Resource();
resource.initialize();
// fails to deactivate
ICapabilityLifecycle mockCapability2 = createMock(ICapabilityLifecycle.class);
mockCapability2.getState();
expectLastCall().andReturn(ICapabilityLifecycle.State.INITIALIZED).anyTimes();
mockCapability2.deactivate(); // @ rollback
expectLastCall().andThrow(new ResourceException());
mockCapability2.shutdown();
expectLastCall().anyTimes();
mockCapability2.initialize();
expectLastCall().atLeastOnce();
mockCapability2.activate();
expectLastCall().atLeastOnce();
replay(mockCapability2);
// fails to activate
ICapabilityLifecycle mockCapability1 = createMock(ICapabilityLifecycle.class);
mockCapability1.getState();
expectLastCall().andReturn(ICapabilityLifecycle.State.INITIALIZED).anyTimes();
mockCapability1.deactivate(); // @ rollback
expectLastCall().anyTimes();
mockCapability1.shutdown();
expectLastCall().anyTimes();
mockCapability1.initialize();
expectLastCall().atLeastOnce();
mockCapability1.activate();
expectLastCall().andThrow(new ResourceException());
replay(mockCapability1);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability2);
capabilities.add(mockCapability1);
resource.setCapabilities(capabilities);
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.bootstrap(resource); // expect a call to bootstrap
expectLastCall().anyTimes(); // it may not happen if deactivate fails first
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
resource.setState(State.INITIALIZED);
boolean hasThrown = false;
try {
resource.activate();
} catch (CorruptStateException e) { // CORRUPT!
hasThrown = true;
}
Assert.assertTrue(hasThrown);
verify(mockBootstrapper);
verify(mockCapability1);
verify(mockCapability2);
Assert.assertTrue(resource.getState().equals(State.ERROR));
} catch (ResourceException e) {
Assert.fail(e.getLocalizedMessage());
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getLocalizedMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getLocalizedMessage());
}
}
@Test
public void deactivateResourceRollbackCorruptTest() {
try {
Resource resource = new Resource();
resource.initialize();
// fails to activate
ICapabilityLifecycle mockCapability1 = createMock(ICapabilityLifecycle.class);
mockCapability1.getState();
expectLastCall().andReturn(ICapabilityLifecycle.State.INITIALIZED).anyTimes();
mockCapability1.deactivate();
expectLastCall().atLeastOnce();
mockCapability1.shutdown();
expectLastCall().atLeastOnce();
mockCapability1.initialize(); // @ rollback
expectLastCall().anyTimes();
mockCapability1.activate();
expectLastCall().andThrow(new ResourceException());
replay(mockCapability1);
// fails to deactivate
ICapabilityLifecycle mockCapability2 = createMock(ICapabilityLifecycle.class);
mockCapability2.getState();
expectLastCall().andReturn(ICapabilityLifecycle.State.INITIALIZED).anyTimes();
mockCapability2.deactivate();
expectLastCall().andThrow(new ResourceException());
mockCapability2.shutdown();
expectLastCall().anyTimes();
mockCapability2.initialize(); // @ rollback
expectLastCall().anyTimes();
mockCapability2.activate();
expectLastCall().anyTimes();
replay(mockCapability2);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability1);
capabilities.add(mockCapability2);
resource.setCapabilities(capabilities);
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.revertBootstrap(resource); // expect a call to bootstrap
expectLastCall().anyTimes(); // it may not happen if deactivate fails first
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
resource.setState(State.ACTIVE);
boolean hasThrown = false;
try {
resource.deactivate();
} catch (CorruptStateException e) { // CORRUPT!
hasThrown = true;
}
Assert.assertTrue(hasThrown);
verify(mockBootstrapper);
verify(mockCapability1);
verify(mockCapability2);
Assert.assertTrue(resource.getState().equals(State.ERROR));
} catch (ResourceException e) {
Assert.fail(e.getLocalizedMessage());
} catch (IncorrectLifecycleStateException e) {
Assert.fail(e.getLocalizedMessage());
} catch (CorruptStateException e) {
Assert.fail(e.getLocalizedMessage());
}
}
@Test
public void forceDeactivateResourceTest() throws IncorrectLifecycleStateException, ResourceException, CorruptStateException {
Resource resource = new Resource();
resource.initialize();
IResourceBootstrapper mockBootstrapper = createMock(IResourceBootstrapper.class);
mockBootstrapper.revertBootstrap(resource);
expectLastCall().andThrow(new ResourceException());
replay(mockBootstrapper);
resource.setBootstrapper(mockBootstrapper);
boolean isThrown = false;
try {
resource.forceDeactivate();
} catch (ResourceException e) {
isThrown = true;
}
Assert.assertTrue(isThrown);
/* check fail capability */
ICapabilityLifecycle mockCapability = createMock(ICapabilityLifecycle.class);
/* force to fail the deactivate method */
mockCapability.deactivate();
expectLastCall().andThrow(new ResourceException()).anyTimes();
replay(mockCapability);
List<ICapability> capabilities = new ArrayList<ICapability>();
capabilities.add(mockCapability);
resource.setCapabilities(capabilities);
resource.setBootstrapper(createMock(IResourceBootstrapper.class));
isThrown = false;
try {
resource.forceDeactivate();
} catch (ResourceException e) {
isThrown = true;
}
Assert.assertTrue(isThrown);
}
}