IrcCatNotificationServiceTest.java

/**
 * 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 com.seyren.core.service.notification;

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;
import static org.mockito.Mockito.*;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import org.junit.Before;
import org.junit.Test;

import com.google.common.io.Closer;
import com.seyren.core.domain.Alert;
import com.seyren.core.domain.AlertType;
import com.seyren.core.domain.Check;
import com.seyren.core.domain.Subscription;
import com.seyren.core.domain.SubscriptionType;
import com.seyren.core.util.config.SeyrenConfig;

public class IrcCatNotificationServiceTest {
    
    private static final int IRCCAT_PORT = 12345;
    private SeyrenConfig mockSeyrenConfig;
    private NotificationService service;
    
    @Before
    public void configureService() {
        mockSeyrenConfig = mock(SeyrenConfig.class);
        service = new IrcCatNotificationService(mockSeyrenConfig);
    }
    
    @Test
    public void notifcationServiceCanOnlyHandleHubotSubscription() {
        assertThat(service.canHandle(SubscriptionType.IRCCAT), is(true));
        for (SubscriptionType type : SubscriptionType.values()) {
            if (type == SubscriptionType.IRCCAT) {
                continue;
            }
            assertThat(service.canHandle(type), is(false));
        }
    }
    
    @Test
    public void sendNotification() throws Exception {
        when(mockSeyrenConfig.getBaseUrl()).thenReturn("http://localhost");
        when(mockSeyrenConfig.getIrcCatHost()).thenReturn("localhost");
        when(mockSeyrenConfig.getIrcCatPort()).thenReturn(IRCCAT_PORT);
        TcpServer tcpServer = new TcpServer(IRCCAT_PORT);
        synchronized (tcpServer) {
            tcpServer.start();
            tcpServer.wait(1000); // Wait for up to 1 second while the server socket is being bound.
        }
        
        Check check = new Check().withEnabled(true).withName("check-name")
                .withState(AlertType.ERROR);
        
        Subscription subscription = new Subscription().withType(
                SubscriptionType.IRCCAT).withTarget("#mychannel");
        
        Alert alert = new Alert().withTarget("the.target.name")
                .withValue(BigDecimal.valueOf(12))
                .withWarn(BigDecimal.valueOf(5))
                .withError(BigDecimal.valueOf(10)).withFromType(AlertType.WARN)
                .withToType(AlertType.ERROR);
        
        List<Alert> alerts = Arrays.asList(alert);
        
        service.sendNotification(check, subscription, alerts);
        
        tcpServer.waitForNumberOfMessage(1, 1000);
        
        assertThat(tcpServer.getMessages().size(), is(1));
        
        verify(mockSeyrenConfig).getIrcCatHost();
        verify(mockSeyrenConfig).getIrcCatPort();
        tcpServer.stop();
    }
    
    private static class TcpServer {
        
        private final int port;
        
        private volatile boolean shutdown = false;
        private final List<String> messages = new CopyOnWriteArrayList<String>();
        private Thread serverThread;
        
        public TcpServer(int port) {
            this.port = port;
        }
        
        public TcpServer start() {
            serverThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    ServerSocket serverSocket = null;
                    try {
                        synchronized (this) {
                            serverSocket = new ServerSocket(port);
                            this.notifyAll(); // Notify now that the server socket is bound.
                        }
                        while (!shutdown) {
                            Socket socket = serverSocket.accept();
                            Closer closer = Closer.create();
                            try {
                                BufferedReader in = closer.register(new BufferedReader(new InputStreamReader(socket.getInputStream())));
                                String message = in.readLine();
                                messages.add(message);
                                synchronized (this) {
                                    this.notifyAll();
                                }
                            } catch (IOException ioe) {
                                socket.close();
                                closer.rethrow(ioe);
                            } finally {
                                closer.close();
                            }
                        }
                    } catch (IOException ioe) {
                    } finally {
                        if (serverSocket != null && !serverSocket.isClosed()) {
                            try {
                                serverSocket.close();
                            } catch (IOException e) {
                                throw new RuntimeException(e);
                            }
                        }
                    }
                }
            });
            serverThread.start();
            return this;
        }
        
        public void waitForNumberOfMessage(int n, long timeout)
                throws InterruptedException {
            long startTime = System.currentTimeMillis();
            while (messages.size() < n) {
                synchronized (this) {
                    this.wait(timeout);
                }
                if (System.currentTimeMillis() - startTime > timeout) {
                    return;
                }
            }
        }
        
        public void stop() {
            shutdown = true;
        }
        
        public List<String> getMessages() {
            return this.messages;
        }
        
    }
    
}