src/test/java/net/floodlightcontroller/core/internal/RoleChangerTest.java

package net.floodlightcontroller.core.internal;

import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.util.Collection;
import java.util.LinkedList;

import net.floodlightcontroller.core.IFloodlightProviderService.Role;
import net.floodlightcontroller.core.IOFSwitch;
import net.floodlightcontroller.core.internal.RoleChanger.RoleChangeTask;

import org.easymock.EasyMock;
import org.jboss.netty.channel.Channel;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;

public class RoleChangerTest {
    public RoleChanger roleChanger;

    @Before
    public void setUp() throws Exception {
        roleChanger = new RoleChanger();
    }

    /**
     * Send a role request for SLAVE to a switch that doesn't support it.
     * The connection should be closed.
     */
    @Test
    public void testSendRoleRequestSlaveNotSupported() {
        LinkedList<OFSwitchImpl> switches = new LinkedList<OFSwitchImpl>();

        // a switch that doesn't support role requests
        OFSwitchImpl sw1 = EasyMock.createMock(OFSwitchImpl.class);
        Channel channel1 = createMock(Channel.class);
        expect(sw1.getChannel()).andReturn(channel1);
        // No support for NX_ROLE
        expect(sw1.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
                .andReturn(false);
        expect(channel1.close()).andReturn(null);
        switches.add(sw1);

        replay(sw1, channel1);
        roleChanger.sendRoleRequest(switches, Role.SLAVE, 123456);
        verify(sw1, channel1);

        // sendRoleRequest needs to remove the switch from the list since
        // it closed its connection
        assertTrue(switches.isEmpty());
    }

    /**
     * Send a role request for MASTER to a switch that doesn't support it.
     * The connection should be closed.
     */
    @Test
    @Ignore
    // FIXME: ONOS modified the behavior here to intentionally trigger OFS error.
    public void testSendRoleRequestMasterNotSupported() {
        LinkedList<OFSwitchImpl> switches = new LinkedList<OFSwitchImpl>();

        // a switch that doesn't support role requests
        OFSwitchImpl sw1 = EasyMock.createMock(OFSwitchImpl.class);
        // No support for NX_ROLE
        expect(sw1.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
                .andReturn(false);
        switches.add(sw1);

        replay(sw1);
        roleChanger.sendRoleRequest(switches, Role.MASTER, 123456);
        verify(sw1);

        assertEquals(1, switches.size());
    }

    /**
     * Send a role request a switch that supports it and one that
     * hasn't had a role request send to it yet
     */
    @Test
    public void testSendRoleRequestErrorHandling() throws Exception {
        LinkedList<OFSwitchImpl> switches = new LinkedList<OFSwitchImpl>();

        // a switch that supports role requests
        OFSwitchImpl sw1 = EasyMock.createMock(OFSwitchImpl.class);
        // No support for NX_ROLE
        expect(sw1.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
                .andReturn(true);
        expect(sw1.sendNxRoleRequest(Role.MASTER, 123456))
                .andThrow(new IOException()).once();
        Channel channel1 = createMock(Channel.class);
        expect(sw1.getChannel()).andReturn(channel1);
        expect(channel1.close()).andReturn(null);
        switches.add(sw1);

        replay(sw1);
        roleChanger.sendRoleRequest(switches, Role.MASTER, 123456);
        verify(sw1);

        assertTrue(switches.isEmpty());
    }

    /**
     * Check error handling
     * hasn't had a role request send to it yet
     */
    @Test
    public void testSendRoleRequestSupported() throws Exception {
        LinkedList<OFSwitchImpl> switches = new LinkedList<OFSwitchImpl>();

        // a switch that supports role requests
        OFSwitchImpl sw1 = EasyMock.createMock(OFSwitchImpl.class);
        // No support for NX_ROLE
        expect(sw1.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
                .andReturn(true);
        expect(sw1.sendNxRoleRequest(Role.MASTER, 123456)).andReturn(1).once();
        switches.add(sw1);

        // a switch for which we don't have SUPPORTS_NX_ROLE yet
        OFSwitchImpl sw2 = EasyMock.createMock(OFSwitchImpl.class);
        // No support for NX_ROLE
        expect(sw2.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
                .andReturn(null);
        expect(sw2.sendNxRoleRequest(Role.MASTER, 123456)).andReturn(1).once();
        switches.add(sw2);


        replay(sw1, sw2);
        roleChanger.sendRoleRequest(switches, Role.MASTER, 123456);
        verify(sw1, sw2);

        assertEquals(2, switches.size());
    }

    @Test
    public void testVerifyRoleReplyReceived() {
        LinkedList<OFSwitchImpl> switches = new LinkedList<OFSwitchImpl>();

        // Add a switch that has received a role reply
        OFSwitchImpl sw1 = EasyMock.createMock(OFSwitchImpl.class);
        expect(sw1.checkFirstPendingRoleRequestCookie(123456))
                .andReturn(false).once();
        switches.add(sw1);

        // Add a switch that has not yet received a role reply
        OFSwitchImpl sw2 = EasyMock.createMock(OFSwitchImpl.class);
        expect(sw2.checkFirstPendingRoleRequestCookie(123456))
                .andReturn(true).once();
        Channel channel2 = createMock(Channel.class);
        expect(sw2.getChannel()).andReturn(channel2);
        expect(channel2.close()).andReturn(null);
        switches.add(sw2);


        replay(sw1, sw2);
        roleChanger.verifyRoleReplyReceived(switches, 123456);
        verify(sw1, sw2);

        assertEquals(2, switches.size());
    }

    @Test
    public void testRoleChangeTask() {
        @SuppressWarnings("unchecked")
        Collection<OFSwitchImpl> switches =
                EasyMock.createMock(Collection.class);
        long now = System.nanoTime();
        long dt1 = 10 * 1000 * 1000 * 1000L;
        long dt2 = 20 * 1000 * 1000 * 1000L;
        long dt3 = 15 * 1000 * 1000 * 1000L;
        RoleChangeTask t1 = new RoleChangeTask(switches, null, now + dt1);
        RoleChangeTask t2 = new RoleChangeTask(switches, null, now + dt2);
        RoleChangeTask t3 = new RoleChangeTask(switches, null, now + dt3);

        // FIXME: cannot test comparison against self. grrr
        //assertTrue( t1.compareTo(t1) <= 0 );
        assertTrue(t1.compareTo(t2) < 0);
        assertTrue(t1.compareTo(t3) < 0);

        assertTrue(t2.compareTo(t1) > 0);
        //assertTrue( t2.compareTo(t2) <= 0 );
        assertTrue(t2.compareTo(t3) > 0);
    }

    @Test
    public void testSubmitRequest() throws Exception {
        LinkedList<OFSwitchImpl> switches = new LinkedList<OFSwitchImpl>();
        roleChanger.timeout = 500 * 1000 * 1000; // 500 ms

        // a switch that supports role requests
        OFSwitchImpl sw1 = EasyMock.createStrictMock(OFSwitchImpl.class);
        // No support for NX_ROLE
        expect(sw1.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
                .andReturn(true);
        expect(sw1.sendNxRoleRequest(EasyMock.same(Role.MASTER), EasyMock.anyLong()))
                .andReturn(1);
        expect(sw1.getAttribute(IOFSwitch.SWITCH_SUPPORTS_NX_ROLE))
                .andReturn(true);
        expect(sw1.sendNxRoleRequest(EasyMock.same(Role.SLAVE), EasyMock.anyLong()))
                .andReturn(1);
        // The following calls happen for timeout handling:
        expect(sw1.checkFirstPendingRoleRequestCookie(EasyMock.anyLong()))
                .andReturn(false);
        expect(sw1.checkFirstPendingRoleRequestCookie(EasyMock.anyLong()))
                .andReturn(false);
        switches.add(sw1);


        replay(sw1);
        roleChanger.submitRequest(switches, Role.MASTER);
        roleChanger.submitRequest(switches, Role.SLAVE);
        // Wait until role request has been sent. 
        // TODO: need to get rid of this sleep somehow
        Thread.sleep(100);
        // Now there should be exactly one timeout task pending
        assertEquals(2, roleChanger.pendingTasks.size());
        // Make sure it's indeed a timeout task
        assertSame(RoleChanger.RoleChangeTask.Type.TIMEOUT,
                roleChanger.pendingTasks.peek().type);
        // Check that RoleChanger indeed made a copy of switches collection
        assertNotSame(switches, roleChanger.pendingTasks.peek().switches);

        // Wait until the timeout triggers 
        // TODO: get rid of this sleep too.
        Thread.sleep(500);
        assertEquals(0, roleChanger.pendingTasks.size());
        verify(sw1);

    }

}