@Test
public void test_user_wrong_salt_hash_format() throws Exception {
final String providedUsername = "******";
when(clientCredentialsData.getUsername()).thenReturn(Optional.of(providedUsername));
final String providedPassword = "******";
when(clientCredentialsData.getPassword()).thenReturn(Optional.of(providedPassword));
when(clientCredentialsData.getInetAddress())
.thenReturn(Optional.of(InetAddress.getLoopbackAddress()));
final String filePassword = "******";
when(configuration.getUser(providedUsername)).thenReturn(filePassword);
when(configuration.isSalted()).thenReturn(true);
when(configuration.isHashed()).thenReturn(true);
final String algorithm = "SHA-512";
when(configuration.getHashingAlgorithm()).thenReturn(algorithm);
final int iterations = 1000000;
when(configuration.getHashingIterations()).thenReturn(iterations);
final String salt = "salt";
final String hash = "hash";
HashedSaltedPassword abc = new HashedSaltedPassword(hash, salt);
fileAuthenticator = new FileAuthenticator(configuration, passwordComparator);
when(passwordComparator.validateHashedAndSaltedPassword(
algorithm, providedPassword, hash, iterations, salt))
.thenReturn(true);
FileAuthenticatorForTest2 fileAuthenticator =
new FileAuthenticatorForTest2(configuration, passwordComparator, abc);
final Boolean isAuthenticated = fileAuthenticator.checkCredentials(clientCredentialsData);
assertFalse(isAuthenticated);
}
private LauncherServer() throws IOException {
this.refCount = new AtomicLong(0);
ServerSocket server = new ServerSocket();
try {
server.setReuseAddress(true);
server.bind(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));
this.clients = new ArrayList<>();
this.threadIds = new AtomicLong();
this.factory = new NamedThreadFactory(THREAD_NAME_FMT);
this.pending = new ConcurrentHashMap<>();
this.timeoutTimer = new Timer("LauncherServer-TimeoutTimer", true);
this.server = server;
this.running = true;
this.serverThread =
factory.newThread(
new Runnable() {
@Override
public void run() {
acceptConnections();
}
});
serverThread.start();
} catch (IOException ioe) {
close();
throw ioe;
} catch (Exception e) {
close();
throw new IOException(e);
}
}
@Test
public void test_user_correct_hashed_password() throws Exception {
final String providedUsername = "******";
when(clientCredentialsData.getUsername()).thenReturn(Optional.of(providedUsername));
final String providedPassword = "******";
when(clientCredentialsData.getPassword()).thenReturn(Optional.of(providedPassword));
when(clientCredentialsData.getInetAddress())
.thenReturn(Optional.of(InetAddress.getLoopbackAddress()));
final String filePassword = "******";
when(configuration.getUser(providedUsername)).thenReturn(filePassword);
when(configuration.isSalted()).thenReturn(false);
when(configuration.isHashed()).thenReturn(true);
final String algorithm = "SHA-512";
when(configuration.getHashingAlgorithm()).thenReturn(algorithm);
final int iterations = 1000000;
when(configuration.getHashingIterations()).thenReturn(iterations);
fileAuthenticator = new FileAuthenticator(configuration, passwordComparator);
when(passwordComparator.validateHashedPassword(
algorithm, providedPassword, filePassword, iterations))
.thenReturn(true);
FileAuthenticator fileAuthenticator = new FileAuthenticator(configuration, passwordComparator);
final Boolean isAuthenticated = fileAuthenticator.checkCredentials(clientCredentialsData);
assertTrue(isAuthenticated);
}
private Map<String, String> resolveTlsVerification(Map<String, String> config) {
URI serverUri = URI.create(config.get(CubeDockerConfiguration.DOCKER_URI));
String scheme = serverUri.getScheme();
if (scheme.equals(HTTP_SCHEME) || scheme.equals(HTTPS_SCHEME)) {
config.put(CubeDockerConfiguration.TLS_VERIFY, Boolean.toString(scheme.equals(HTTPS_SCHEME)));
try {
// docker-java supports only tcp and unix schemes
serverUri = new URI(TCP_SCHEME, serverUri.getSchemeSpecificPart(), serverUri.getFragment());
config.put(CubeDockerConfiguration.DOCKER_URI, serverUri.toString());
} catch (URISyntaxException e) {
throw new IllegalArgumentException(e);
}
}
if (!config.containsKey(CubeDockerConfiguration.TLS_VERIFY)) {
config.put(CubeDockerConfiguration.TLS_VERIFY, Boolean.toString(true));
if (this.operatingSystemFamilyInstanceProducer.get() == OperatingSystemFamily.LINUX) {
String dockerServerIp = config.get(CubeDockerConfiguration.DOCKER_SERVER_IP);
if (isDockerMachineSet(config)) {
if (InetAddress.getLoopbackAddress().getHostAddress().equals(dockerServerIp)
|| InetAddress.getLoopbackAddress().getHostName().equals(dockerServerIp)) {
config.put(CubeDockerConfiguration.TLS_VERIFY, Boolean.toString(false));
} else {
config.put(CubeDockerConfiguration.TLS_VERIFY, Boolean.toString(true));
}
} else {
config.put(CubeDockerConfiguration.TLS_VERIFY, Boolean.toString(false));
}
}
}
if (Boolean.FALSE.toString().equals(config.get(CubeDockerConfiguration.TLS_VERIFY))) {
config.remove(CubeDockerConfiguration.CERT_PATH);
}
return config;
}
// constructor with exception
public ClientCommunicate(int port) throws IOException {
port_number = port;
loopback = InetAddress.getLoopbackAddress();
// try to connect to server
client_socket = new Socket(loopback, port_number);
// grab the output and input streams
output = new PrintWriter(client_socket.getOutputStream(), true);
input = new BufferedReader(new InputStreamReader(client_socket.getInputStream()));
}
@NotNull
default InetSocketAddress computeDebugAddress() throws ExecutionException {
try {
return new InetSocketAddress(
InetAddress.getLoopbackAddress(), NetUtils.findAvailableSocketPort());
} catch (IOException e) {
throw new ExecutionException("Cannot find available port", e);
}
}
@Override
public String getRemote() {
try {
return localhost.getAddress();
} catch (
@SuppressWarnings("unused")
final UnknownHostException e) {
return InetAddress.getLoopbackAddress().getHostAddress();
}
}
/** @return never returns <code>null</code> */
public static IHostIdentifier getLocalHost() {
InetAddress localHostAddress;
try {
localHostAddress = InetAddress.getLocalHost();
} catch (UnknownHostException e) {
// fallback
localHostAddress = InetAddress.getLoopbackAddress();
}
return of(localHostAddress);
}
@Test
public void testManageAttributes() throws ParseException {
Map<String, Collection<String>> map = new HashedMap();
map.put("integer", asList("1"));
map.put("long", asList("" + Long.MAX_VALUE));
map.put("string", asList("some string"));
map.put("date", asList("12/12/2016"));
map.put("ip_network_address", asList("127.0.0.1"));
map.put("host_network_address", asList("localhost"));
map.put("multi_valued", asList("1", "2", "3", "4"));
Attributes attributes = Attributes.from(map);
map.keySet()
.forEach(
new Consumer<String>() {
@Override
public void accept(String name) {
assertTrue(attributes.exists(name));
}
});
assertFalse(attributes.exists("not_found"));
assertTrue(attributes.containsValue("integer", "1"));
assertTrue(attributes.containsValue("multi_valued", "3"));
assertEquals(1, attributes.getValue("multi_valued").asInt(0));
assertEquals(4, attributes.getValue("multi_valued").asInt(3));
assertEquals(
new SimpleDateFormat("dd/MM/yyyy").parse("12/12/2016"),
attributes.getValue("date").asDate(0, "dd/MM/yyyy"));
assertEquals(
InetAddress.getLoopbackAddress(),
attributes.getValue("ip_network_address").asInetAddress(0));
assertEquals(
InetAddress.getLoopbackAddress(),
attributes.getValue("host_network_address").asInetAddress(0));
}
@Test
public void test_no_password() throws Exception {
when(clientCredentialsData.getUsername()).thenReturn(Optional.of("user"));
when(clientCredentialsData.getPassword()).thenReturn(Optional.<String>absent());
when(clientCredentialsData.getInetAddress())
.thenReturn(Optional.of(InetAddress.getLoopbackAddress()));
fileAuthenticator = new FileAuthenticator(configuration, passwordComparator);
final Boolean isAuthenticated = fileAuthenticator.checkCredentials(clientCredentialsData);
assertFalse(isAuthenticated);
}
@Test
public ReadHandle make() {
ArrayList<SocketAddress> clusterMembers = new ArrayList<SocketAddress>();
clusterMembers.add(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));
Var<Addr> cluster = Var$.MODULE$.apply(Addr.Bound$.MODULE$.apply(clusterMembers));
return MultiReader.apply(cluster, "the-queue")
.clientBuilder(
ClientBuilder.get()
.codec(new Kestrel())
.hostConnectionLimit(1)
.requestTimeout(Duration.fromTimeUnit(30, TimeUnit.SECONDS)))
.build();
}
@Test
public void test_user_is_not_present_in_credential_file() throws Exception {
final String providedUsername = "******";
when(clientCredentialsData.getUsername()).thenReturn(Optional.of(providedUsername));
when(clientCredentialsData.getPassword()).thenReturn(Optional.of("password"));
when(clientCredentialsData.getInetAddress())
.thenReturn(Optional.of(InetAddress.getLoopbackAddress()));
when(configuration.getUser(providedUsername)).thenReturn(null);
fileAuthenticator = new FileAuthenticator(configuration, passwordComparator);
final Boolean isAuthenticated = fileAuthenticator.checkCredentials(clientCredentialsData);
assertFalse(isAuthenticated);
}
private static void runServer() {
Service<Request, Response> service =
new Service<Request, Response>() {
public Future<Response> apply(Request request) {
Response response = Response.apply();
// Respond right away.
response.setContent(ChannelBuffers.wrappedBuffer("yo".getBytes()));
Future<Response> future = Future.value(response);
return future;
}
};
ServerBuilder.safeBuild(
service,
ServerBuilder.get()
.codec(Http.get())
.bindTo(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0))
.name("HttpServer"));
}
@Test
public void test_user_correct_plaintext_password() throws Exception {
final String providedUsername = "******";
when(clientCredentialsData.getUsername()).thenReturn(Optional.of(providedUsername));
final String providedPassword = "******";
when(clientCredentialsData.getPassword()).thenReturn(Optional.of(providedPassword));
when(clientCredentialsData.getInetAddress())
.thenReturn(Optional.of(InetAddress.getLoopbackAddress()));
final String filePassword = "******";
when(configuration.getUser(providedUsername)).thenReturn(filePassword);
when(configuration.isHashed()).thenReturn(false);
when(passwordComparator.validatePlaintextPassword(filePassword, providedPassword))
.thenReturn(true);
fileAuthenticator = new FileAuthenticator(configuration, passwordComparator);
final Boolean isAuthenticated = fileAuthenticator.checkCredentials(clientCredentialsData);
assertTrue(isAuthenticated);
}
/** Test case for https://issues.apache.org/jira/browse/ZOOKEEPER-2299 */
@Test
public void testClientAddress() throws Exception {
QuorumPeer quorumPeer = new QuorumPeer();
LocalPeerBean remotePeerBean = new LocalPeerBean(quorumPeer);
/** Case 1: When cnxnFactory is null */
String result = remotePeerBean.getClientAddress();
assertNotNull(result);
assertEquals(0, result.length());
/** Case 2: When only client port is configured */
ServerCnxnFactory cnxnFactory = ServerCnxnFactory.createFactory();
int clientPort = PortAssignment.unique();
InetSocketAddress address = new InetSocketAddress(clientPort);
cnxnFactory.configure(address, 5, false);
quorumPeer.setCnxnFactory(cnxnFactory);
result = remotePeerBean.getClientAddress();
String ipv4 = "0.0.0.0:" + clientPort;
String ipv6 = "0:0:0:0:0:0:0:0:" + clientPort;
assertTrue(result.equals(ipv4) || result.equals(ipv6));
// cleanup
cnxnFactory.shutdown();
/** Case 3: When both client port and client address is configured */
clientPort = PortAssignment.unique();
InetAddress clientIP = InetAddress.getLoopbackAddress();
address = new InetSocketAddress(clientIP, clientPort);
cnxnFactory = ServerCnxnFactory.createFactory();
cnxnFactory.configure(address, 5, false);
quorumPeer.setCnxnFactory(cnxnFactory);
result = remotePeerBean.getClientAddress();
String expectedResult = clientIP.getHostAddress() + ":" + clientPort;
assertEquals(expectedResult, result);
// cleanup
cnxnFactory.shutdown();
}
private synchronized RConnection connectLocal() {
Logger.getLogger(RserveConnectionFactory.class.getName())
.info("Trying to connect to local Rserve ...");
RConnection connection = null;
RserveConnection rserveConnection;
try {
Logger.getLogger(RserveConnectionFactory.class.getName())
.info("Checking for an already running Rserve");
rserveConnection = new RserveConnection(InetAddress.getLoopbackAddress(), 6311, false);
connection = rserveConnection.getConnection();
isLocalServer = true;
Logger.getLogger(RserveConnectionFactory.class.getName())
.info("Found an already running Rserve instance!");
setConnection(connection);
return connection;
} catch (RserveException ex) {
Logger.getLogger(RserveConnectionFactory.class.getName())
.severe(
"Received an Rserve Exception: "
+ ex.getLocalizedMessage()
+ " with description: "
+ ex.getRequestErrorDescription());
Logger.getLogger(RserveConnectionFactory.class.getName())
.info("Failed to connect to local Rserve ... launching new local instance!");
connection = startLocalAndConnect();
if (connection != null) {
if (connection.isConnected()) {
isLocalServer = true;
setConnection(connection);
Logger.getLogger(RserveConnectionFactory.class.getName()).info("Connected to Rserve!");
return connection;
}
}
}
throw new NullPointerException();
}
/**
* Should we make it singleton?
*
* @author Vicho
*/
public class SecureNetworkMessenger implements Runnable {
private static Map<String, MessageResponder> responders = new HashMap<String, MessageResponder>();
private static ObjectOutputStream outgoingSerial;
private static ObjectInputStream incomingSerial;
private static final InetAddress localhost = InetAddress.getLoopbackAddress();
private static final int PORT = 2343;
private static MessageQueue incomingMessagesQueue = MessageQueue.getInstance();
private static final SecureNetworkMessenger instance = new SecureNetworkMessenger();
public static SecureNetworkMessenger getSecureInstance() {
return SecureNetworkMessenger.instance;
}
private SecureNetworkMessenger() {
/*
* Here we should add the various message responders?
*/
registerResponder(new AddTicketResponder());
}
private void registerResponder(MessageResponder responder) {
responders.put(responder.getType(), responder);
}
public static MessageResponder getResponder(String msgType) {
return responders.get(msgType);
}
@Override
public void run() {
SSLServerSocketFactory sslserversocketfactory =
(SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
SSLServerSocket sslserversocket;
try {
System.out.println("Desktop starting at port " + PORT);
sslserversocket = (SSLServerSocket) sslserversocketfactory.createServerSocket();
// certificate is made with: "keytool -genkey keystore -keyalg RSA"
// this below is a 'hack' (the hack was adding all cipher suites, this is the only one we need
sslserversocket.setEnabledCipherSuites(new String[] {"SSL_DH_anon_WITH_3DES_EDE_CBC_SHA"});
sslserversocket.bind(new InetSocketAddress(localhost, PORT));
SSLSocket sslsocket = (SSLSocket) sslserversocket.accept();
InputStream inputstream = sslsocket.getInputStream();
OutputStream outputstream = sslsocket.getOutputStream();
outgoingSerial = new ObjectOutputStream(outputstream);
incomingSerial =
new ObjectInputStream(inputstream) {
// @Override
// public Object readObject(){
//
// }
};
} catch (IOException e) {
e.printStackTrace();
}
sendNewTicketType();
// executor.scheduleAtFixedRate(new Runnable() {
//
// @Override
// public void run() {
while (true) {
waitForMessages();
}
// System.out.println("are we finished?");
//
// }
// }, 0, 50, TimeUnit.MILLISECONDS);
// in the rest of the lifetime...
}
private static void sendNewTicketType() {
TicketType tt = new TicketType("the reason", 5, 3);
NetworkMessage tobesent = new NetworkMessage(Messages.ADD_TICKET_TYPE, tt);
try {
outgoingSerial.writeObject(tobesent);
} catch (IOException e) {
e.printStackTrace();
}
}
// taken from the messenger:
private void waitForMessages() {
Object message = null;
System.out.println("x");
try {
if ((message = incomingSerial.readObject()) != null) {
NetworkMessage incomingMessage = (NetworkMessage) message;
System.out.println("recieved it!");
if (incomingMessage == null
|| incomingMessage.getData() == null
|| incomingMessage.getType() == null
|| incomingMessage.getType() == "") {
System.out.println("it is corrupt!");
return;
}
try {
System.out.println("getting on board..");
incomingMessagesQueue.put(incomingMessage);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public boolean sendMessage(String msgType, Serializable data) {
NetworkMessage message = new NetworkMessage(msgType, data);
try {
outgoingSerial.writeObject(message);
} catch (IOException e) {
e.printStackTrace();
return false;
}
return true;
}
}
@Test
public void sendIdempotent() throws Exception {
TestReceiver serverReceiver = new TestReceiver();
Function<Transport, FixpSession> clientAcceptor =
new Function<Transport, FixpSession>() {
public FixpSession apply(Transport serverTransport) {
try {
FixpSession serverSession =
FixpSession.builder()
.withReactor(engine.getReactor())
.withTransport(serverTransport)
.withBufferSupplier(
new SingleBufferSupplier(
ByteBuffer.allocate(16 * 1024).order(ByteOrder.nativeOrder())))
.withMessageConsumer(serverReceiver)
.withOutboundFlow(FlowType.Idempotent)
.withOutboundKeepaliveInterval(keepAliveInterval)
.asServer()
.build();
serverSession.open();
return serverSession;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
};
KeyStore ksKeys = Crypto.createKeyStore();
Crypto.addKeyCertificateEntry(ksKeys, "exchange", "CN=trading, O=myorg, C=US", storePassphrase);
KeyStore ksTrust = Crypto.createKeyStore();
Crypto.addKeyCertificateEntry(
ksTrust, "customer", "CN=Trader1, O=SomeFCM, C=US", storePassphrase);
final InetSocketAddress serverAddress =
new InetSocketAddress(InetAddress.getLoopbackAddress(), 7741);
try (TlsTcpAcceptor tcpAcceptor =
new TlsTcpAcceptor(
engine.getIOReactor().getSelector(),
serverAddress,
ksKeys,
ksTrust,
storePassphrase,
clientAcceptor)) {
tcpAcceptor.open().get();
Transport clientTransport =
new TlsTcpConnectorTransport(
engine.getIOReactor().getSelector(), serverAddress, ksTrust, ksKeys, storePassphrase);
TestReceiver clientReceiver = new TestReceiver();
UUID sessionId = SessionId.generateUUID();
FixpSession clientSession =
FixpSession.builder()
.withReactor(reactor2)
.withTransport(clientTransport)
.withBufferSupplier(
new SingleBufferSupplier(
ByteBuffer.allocate(16 * 1024).order(ByteOrder.nativeOrder())))
.withMessageConsumer(clientReceiver)
.withOutboundFlow(FlowType.Idempotent)
.withSessionId(sessionId)
.withClientCredentials(userCredentials.getBytes())
.withOutboundKeepaliveInterval(keepAliveInterval)
.build();
SessionReadyFuture readyFuture = new SessionReadyFuture(sessionId, reactor2);
// Completes when transport is established or throws if IO error
clientSession.open().get(1000, TimeUnit.MILLISECONDS);
// Completes when FIXP session is established
readyFuture.get(3000, TimeUnit.MILLISECONDS);
ByteBuffer buf = ByteBuffer.allocate(8096).order(ByteOrder.nativeOrder());
int bytesSent = 0;
for (int i = 0; i < messageCount; ++i) {
buf.clear();
bytesSent += encodeApplicationMessageWithFrame(buf, messages[i]);
clientSession.send(buf);
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
assertEquals(messageCount, serverReceiver.getMsgsReceived());
SessionTerminatedFuture terminatedFuture = new SessionTerminatedFuture(sessionId, reactor2);
clientSession.close();
terminatedFuture.get(1000, TimeUnit.MILLISECONDS);
}
}
/**
* @author V. Arun
* <p>This class has no special fields in addition to a generic ClientReconfigurationPacket. It
* just needs information about isFailed(), the correct set of reconfigurators, and the response
* message, all of which are in ClientReconfigurationPacket anyway.
*/
public class DeleteServiceName extends ClientReconfigurationPacket {
/** Needed for unstringing InetSocketAddresses. */
protected static final Stringifiable<InetSocketAddress> unstringer =
new StringifiableDefault<InetSocketAddress>(
new InetSocketAddress(InetAddress.getLoopbackAddress(), 0));
/** @param name */
public DeleteServiceName(String name) {
this(null, name, 0);
}
/**
* @param initiator
* @param name
* @param epochNumber
*/
public DeleteServiceName(InetSocketAddress initiator, String name, int epochNumber) {
this(initiator, name, epochNumber, null);
}
/**
* @param initiator
* @param name
* @param epochNumber
* @param myReceiver
*/
public DeleteServiceName(
InetSocketAddress initiator, String name, int epochNumber, InetSocketAddress myReceiver) {
super(
initiator,
ReconfigurationPacket.PacketType.DELETE_SERVICE_NAME,
name,
epochNumber,
myReceiver);
}
/**
* @param json
* @param unstringer
* @throws JSONException
*/
public DeleteServiceName(JSONObject json, Stringifiable<?> unstringer) throws JSONException {
super(json, DeleteServiceName.unstringer); // ignores unstringer
// assert (this.getSender() != null) : json;
// this.setSender(JSONNIOTransport.getSenderAddress(json));
}
/**
* @param json
* @throws JSONException
*/
public DeleteServiceName(JSONObject json) throws JSONException {
this(json, unstringer);
}
public JSONObject toJSONObjectImpl() throws JSONException {
JSONObject json = super.toJSONObjectImpl();
return json;
}
}
public class PircBotXChatServiceTest extends AbstractPlainJavaFxTest {
public static final String CHAT_USER_NAME = "junit";
public static final String CHAT_PASSWORD = "******";
private static final InetAddress LOOPBACK_ADDRESS = InetAddress.getLoopbackAddress();
private static final long TIMEOUT = 3000;
private static final TimeUnit TIMEOUT_UNIT = TimeUnit.MILLISECONDS;
private static final String DEFAULT_CHANNEL_NAME = "#defaultChannel";
private static final String OTHER_CHANNEL_NAME = "#otherChannel";
private static final int IRC_SERVER_PORT = 123;
private PircBotXChatService instance;
private ChatUser chatUser1;
private ChatUser chatUser2;
@Mock private User user1;
@Mock private User user2;
@Mock private Channel defaultChannel;
@Mock private PircBotX pircBotX;
@Mock private Configuration configuration;
@Mock private ListenerManager listenerManager;
@Mock private UserChannelDaoSnapshot daoSnapshot;
@Mock private UserSnapshot userSnapshot;
@Mock private ChannelSnapshot channelSnapshot;
@Mock private OutputIRC outputIrc;
@Mock private UserService userService;
@Mock private TaskService taskService;
@Mock private PreferencesService preferencesService;
@Mock private Preferences preferences;
@Mock private ChatPrefs chatPrefs;
@Mock private I18n i18n;
@Mock private PircBotXFactory pircBotXFactory;
@Mock private UserChannelDao<User, Channel> userChannelDao;
@Mock private MapProperty<String, Color> userToColorProperty;
@Mock private ObjectProperty<ChatColorMode> chatColorMode;
@Mock private FafService fafService;
@Mock private ExecutorService executorService;
@Mock private UserHostmask userHostMask;
private CountDownLatch botShutdownLatch;
private CompletableFuture<Object> botStartedFuture;
private BooleanProperty loggedInProperty;
@Before
public void setUp() throws Exception {
instance = new PircBotXChatService();
instance.fafService = fafService;
instance.userService = userService;
instance.taskService = taskService;
instance.i18n = i18n;
instance.pircBotXFactory = pircBotXFactory;
instance.preferencesService = preferencesService;
instance.executorService = executorService;
chatUser1 = new ChatUser("chatUser1", null);
chatUser2 = new ChatUser("chatUser2", null);
loggedInProperty = new SimpleBooleanProperty();
botShutdownLatch = new CountDownLatch(1);
userToColorProperty = new SimpleMapProperty<>(FXCollections.observableHashMap());
chatColorMode = new SimpleObjectProperty<>(CUSTOM);
when(userService.getUsername()).thenReturn(CHAT_USER_NAME);
when(userService.getPassword()).thenReturn(CHAT_PASSWORD);
when(userService.loggedInProperty()).thenReturn(loggedInProperty);
when(user1.getNick()).thenReturn(chatUser1.getUsername());
when(user1.getChannels()).thenReturn(ImmutableSortedSet.of(defaultChannel));
when(user1.getUserLevels(defaultChannel)).thenReturn(ImmutableSortedSet.of(UserLevel.VOICE));
when(user2.getNick()).thenReturn(chatUser2.getUsername());
when(user2.getChannels()).thenReturn(ImmutableSortedSet.of(defaultChannel));
when(user2.getUserLevels(defaultChannel)).thenReturn(ImmutableSortedSet.of(UserLevel.VOICE));
when(defaultChannel.getName()).thenReturn(DEFAULT_CHANNEL_NAME);
when(pircBotX.getConfiguration()).thenReturn(configuration);
when(pircBotX.sendIRC()).thenReturn(outputIrc);
when(pircBotX.getUserChannelDao()).thenReturn(userChannelDao);
doAnswer(
invocation -> {
CompletableFuture<Object> future = new CompletableFuture<>();
WaitForAsyncUtils.async(
() -> {
invocation.getArgumentAt(0, Task.class).run();
future.complete(null);
});
return future;
})
.when(executorService)
.submit(any(Task.class));
botStartedFuture = new CompletableFuture<>();
doAnswer(
invocation -> {
botStartedFuture.complete(true);
botShutdownLatch.await();
return null;
})
.when(pircBotX)
.startBot();
when(pircBotXFactory.createPircBotX(any())).thenReturn(pircBotX);
when(configuration.getListenerManager()).thenReturn(listenerManager);
instance.ircHost = LOOPBACK_ADDRESS.getHostAddress();
instance.ircPort = IRC_SERVER_PORT;
instance.defaultChannelName = DEFAULT_CHANNEL_NAME;
instance.reconnectDelay = 100;
when(preferencesService.getPreferences()).thenReturn(preferences);
when(preferences.getChat()).thenReturn(chatPrefs);
when(chatPrefs.userToColorProperty()).thenReturn(userToColorProperty);
when(chatPrefs.chatColorModeProperty()).thenReturn(chatColorMode);
instance.postConstruct();
}
@After
public void tearDown() {
instance.close();
botShutdownLatch.countDown();
}
@Test
public void testOnChatUserList() throws Exception {
ObservableMap<String, ChatUser> usersForChannel =
instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME);
assertThat(usersForChannel.values(), empty());
Map<String, ChatUser> users = new HashMap<>();
users.put(chatUser1.getUsername(), chatUser1);
users.put(chatUser2.getUsername(), chatUser2);
instance.onChatUserList(DEFAULT_CHANNEL_NAME, users);
assertThat(usersForChannel.values(), hasSize(2));
assertThat(usersForChannel.get(chatUser1.getUsername()), sameInstance(chatUser1));
assertThat(usersForChannel.get(chatUser2.getUsername()), sameInstance(chatUser2));
}
@Test
public void testOnUserJoinedChannel() throws Exception {
ObservableMap<String, ChatUser> usersForChannel =
instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME);
assertThat(usersForChannel.values(), empty());
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser2);
assertThat(usersForChannel.values(), hasSize(2));
assertThat(usersForChannel.get(chatUser1.getUsername()), sameInstance(chatUser1));
assertThat(usersForChannel.get(chatUser2.getUsername()), sameInstance(chatUser2));
}
@Test
public void testOnChatUserLeftChannel() throws Exception {
ObservableMap<String, ChatUser> usersForChannel =
instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME);
assertThat(usersForChannel.values(), empty());
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser2);
instance.onChatUserLeftChannel(chatUser1.getUsername(), DEFAULT_CHANNEL_NAME);
assertThat(usersForChannel.values(), hasSize(1));
assertThat(usersForChannel.get(chatUser2.getUsername()), sameInstance(chatUser2));
}
@Test
public void testOnChatUserQuit() throws Exception {
ObservableMap<String, ChatUser> usersForChannel =
instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME);
assertThat(usersForChannel.values(), empty());
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser2);
instance.onChatUserQuit(chatUser1.getUsername());
assertThat(usersForChannel.values(), hasSize(1));
assertThat(usersForChannel.get(chatUser2.getUsername()), sameInstance(chatUser2));
}
@Test
public void testAddOnMessageListenerWithMessage() throws Exception {
CompletableFuture<String> channelNameFuture = new CompletableFuture<>();
CompletableFuture<ChatMessage> chatMessageFuture = new CompletableFuture<>();
instance.addOnMessageListener(
(channelName, chatMessage) -> {
channelNameFuture.complete(channelName);
chatMessageFuture.complete(chatMessage);
});
String message = "chat message";
User user = mock(User.class);
when(user.getNick()).thenReturn(chatUser1.getUsername());
Channel channel = mock(Channel.class);
when(channel.getName()).thenReturn(DEFAULT_CHANNEL_NAME);
UserHostmask userHostMask = mock(UserHostmask.class);
ImmutableMap<String, String> tags = new ImmutableMap.Builder<String, String>().build();
instance.onEvent(
new MessageEvent(
pircBotX, channel, DEFAULT_CHANNEL_NAME, userHostMask, user, message, tags));
assertThat(channelNameFuture.get(), is(DEFAULT_CHANNEL_NAME));
assertThat(chatMessageFuture.get().getMessage(), is(message));
assertThat(chatMessageFuture.get().getUsername(), is(chatUser1.getUsername()));
assertThat(
chatMessageFuture.get().getTime(),
is(greaterThan(Instant.ofEpochMilli(System.currentTimeMillis() - 1000))));
assertThat(chatMessageFuture.get().isAction(), is(false));
}
@Test
public void testAddOnMessageListenerWithAction() throws Exception {
CompletableFuture<String> channelNameFuture = new CompletableFuture<>();
CompletableFuture<ChatMessage> chatMessageFuture = new CompletableFuture<>();
instance.addOnMessageListener(
(channelName, chatMessage) -> {
channelNameFuture.complete(channelName);
chatMessageFuture.complete(chatMessage);
});
String action = "chat action";
User user = mock(User.class);
when(user.getNick()).thenReturn(chatUser1.getUsername());
Channel channel = mock(Channel.class);
when(channel.getName()).thenReturn(DEFAULT_CHANNEL_NAME);
UserHostmask userHostMask = mock(UserHostmask.class);
instance.onEvent(
new ActionEvent(pircBotX, userHostMask, user, channel, DEFAULT_CHANNEL_NAME, action));
assertThat(channelNameFuture.get(), is(DEFAULT_CHANNEL_NAME));
assertThat(chatMessageFuture.get().getMessage(), is(action));
assertThat(chatMessageFuture.get().getUsername(), is(chatUser1.getUsername()));
assertThat(
chatMessageFuture.get().getTime(),
is(greaterThan(Instant.ofEpochMilli(System.currentTimeMillis() - 1000))));
assertThat(chatMessageFuture.get().isAction(), is(true));
}
@Test
public void testAddOnPrivateChatMessageListener() throws Exception {
CompletableFuture<String> usernameFuture = new CompletableFuture<>();
CompletableFuture<ChatMessage> chatMessageFuture = new CompletableFuture<>();
instance.addOnPrivateChatMessageListener(
(username, chatMessage) -> {
usernameFuture.complete(username);
chatMessageFuture.complete(chatMessage);
});
String message = "private message";
User user = mock(User.class);
when(user.getNick()).thenReturn(chatUser1.getUsername());
Channel channel = mock(Channel.class);
when(channel.getName()).thenReturn(DEFAULT_CHANNEL_NAME);
UserHostmask userHostMask = mock(UserHostmask.class);
instance.onEvent(new PrivateMessageEvent(pircBotX, userHostMask, user, message));
assertThat(chatMessageFuture.get().getMessage(), is(message));
assertThat(chatMessageFuture.get().getUsername(), is(chatUser1.getUsername()));
assertThat(
chatMessageFuture.get().getTime(),
is(greaterThan(Instant.ofEpochMilli(System.currentTimeMillis() - 1000))));
assertThat(chatMessageFuture.get().isAction(), is(false));
}
@Test
public void testAddOnChatConnectedListener() throws Exception {
CompletableFuture<Boolean> onChatConnectedFuture = new CompletableFuture<>();
instance
.connectionStateProperty()
.addListener(
(observable, oldValue, newValue) -> {
switch (newValue) {
case CONNECTED:
onChatConnectedFuture.complete(null);
break;
}
});
String password = "******";
when(userService.getPassword()).thenReturn(password);
mockTaskService();
instance.onEvent(new ConnectEvent(pircBotX));
assertThat(onChatConnectedFuture.get(TIMEOUT, TIMEOUT_UNIT), is(nullValue()));
}
@SuppressWarnings("unchecked")
private void mockTaskService() {
doAnswer(
(InvocationOnMock invocation) -> {
PrioritizedTask<Boolean> prioritizedTask =
invocation.getArgumentAt(0, PrioritizedTask.class);
prioritizedTask.run();
Future<Boolean> result = WaitForAsyncUtils.asyncFx(prioritizedTask::getValue);
return CompletableFuture.completedFuture(result.get(1, TimeUnit.SECONDS));
})
.when(instance.taskService)
.submitTask(any());
}
@Test
public void testAddOnUserListListener() throws Exception {
CompletableFuture<String> channelNameFuture = new CompletableFuture<>();
CompletableFuture<Map<String, ChatUser>> usersFuture = new CompletableFuture<>();
instance.addOnUserListListener(
(channelName, users) -> {
channelNameFuture.complete(channelName);
usersFuture.complete(users);
});
when(chatPrefs.getChatColorMode()).thenReturn(chatColorMode.get());
when(chatPrefs.getUserToColor()).thenReturn(userToColorProperty);
when(user2.compareTo(user1)).thenReturn(1);
ImmutableSortedSet<User> users = ImmutableSortedSet.of(user1, user2);
instance.onEvent(new UserListEvent(pircBotX, defaultChannel, users, true));
assertThat(channelNameFuture.get(TIMEOUT, TIMEOUT_UNIT), is(DEFAULT_CHANNEL_NAME));
Map<String, ChatUser> userMap = usersFuture.get(TIMEOUT, TIMEOUT_UNIT);
assertThat(userMap.values(), hasSize(2));
assertThat(userMap.get(chatUser1.getUsername()), is(chatUser1));
assertThat(userMap.get(chatUser2.getUsername()), is(chatUser2));
}
@Test
public void testAddOnChatDisconnectedListener() throws Exception {
CompletableFuture<Void> onChatDisconnectedFuture = new CompletableFuture<>();
instance
.connectionStateProperty()
.addListener(
(observable, oldValue, newValue) -> {
switch (newValue) {
case DISCONNECTED:
onChatDisconnectedFuture.complete(null);
break;
}
});
instance.onEvent(new DisconnectEvent(pircBotX, daoSnapshot, null));
onChatDisconnectedFuture.get(TIMEOUT, TIMEOUT_UNIT);
}
@Test
public void testAddOnChatUserJoinedChannelListener() throws Exception {
when(chatPrefs.getChatColorMode()).thenReturn(chatColorMode.get());
when(chatPrefs.getUserToColor()).thenReturn(userToColorProperty);
CompletableFuture<String> channelNameFuture = new CompletableFuture<>();
CompletableFuture<ChatUser> userFuture = new CompletableFuture<>();
instance.addOnChatUserJoinedChannelListener(
(channelName, chatUser) -> {
channelNameFuture.complete(channelName);
userFuture.complete(chatUser);
});
instance.onEvent(new JoinEvent(pircBotX, defaultChannel, userHostMask, user1));
assertThat(channelNameFuture.get(TIMEOUT, TIMEOUT_UNIT), is(DEFAULT_CHANNEL_NAME));
assertThat(userFuture.get(TIMEOUT, TIMEOUT_UNIT), is(chatUser1));
}
@Test
public void testAddOnChatUserLeftChannelListener() throws Exception {
CompletableFuture<String> usernameFuture = new CompletableFuture<>();
CompletableFuture<String> channelNameFuture = new CompletableFuture<>();
instance.addOnChatUserLeftChannelListener(
(username, channelName) -> {
usernameFuture.complete(username);
channelNameFuture.complete(channelName);
});
when(channelSnapshot.getName()).thenReturn(DEFAULT_CHANNEL_NAME);
when(userSnapshot.getNick()).thenReturn(chatUser1.getUsername());
String reason = "Part reason";
instance.onEvent(
new PartEvent(pircBotX, daoSnapshot, channelSnapshot, userHostMask, userSnapshot, reason));
assertThat(channelNameFuture.get(TIMEOUT, TIMEOUT_UNIT), is(DEFAULT_CHANNEL_NAME));
assertThat(usernameFuture.get(TIMEOUT, TIMEOUT_UNIT), is(chatUser1.getUsername()));
}
@Test
public void testAddOnModeratorSetListener() throws Exception {
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
ObservableSet<String> moderatorInChannels =
instance
.getChatUsersForChannel(DEFAULT_CHANNEL_NAME)
.get(chatUser1.getUsername())
.getModeratorInChannels();
assertThat(moderatorInChannels, empty());
instance.onModeratorSet(DEFAULT_CHANNEL_NAME, chatUser1.getUsername());
assertThat(moderatorInChannels, hasSize(1));
assertThat(moderatorInChannels.iterator().next(), is(DEFAULT_CHANNEL_NAME));
}
@Test
public void testAddOnChatUserQuitListener() throws Exception {
CompletableFuture<Boolean> quitFuture = new CompletableFuture<>();
instance.addOnChatUserQuitListener((username) -> quitFuture.complete(true));
instance.onEvent(new QuitEvent(pircBotX, daoSnapshot, userHostMask, userSnapshot, "reason"));
assertThat(quitFuture.get(TIMEOUT, TIMEOUT_UNIT), is(true));
}
@Test
@SuppressWarnings("unchecked")
public void testConnect() throws Exception {
ArgumentCaptor<Configuration> captor = ArgumentCaptor.forClass(Configuration.class);
instance.connect();
botStartedFuture.get(TIMEOUT, TIMEOUT_UNIT);
verify(pircBotX).startBot();
verify(pircBotXFactory).createPircBotX(captor.capture());
Configuration configuration = captor.getValue();
assertThat(configuration.getName(), is(CHAT_USER_NAME));
assertThat(configuration.getLogin(), is(CHAT_USER_NAME));
assertThat(configuration.getRealName(), is(CHAT_USER_NAME));
assertThat(
configuration.getServers().get(0).getHostname(), is(LOOPBACK_ADDRESS.getHostAddress()));
assertThat(configuration.getServers().get(0).getPort(), is(IRC_SERVER_PORT));
}
@Test
public void testReconnect() throws Exception {
CompletableFuture<Boolean> firstStartFuture = new CompletableFuture<>();
CompletableFuture<Boolean> secondStartFuture = new CompletableFuture<>();
doAnswer(
invocation -> {
if (!firstStartFuture.isDone()) {
firstStartFuture.complete(true);
throw new IOException("test exception");
}
secondStartFuture.complete(true);
botShutdownLatch.await();
return null;
})
.when(pircBotX)
.startBot();
instance.connect();
firstStartFuture.get(TIMEOUT, TIMEOUT_UNIT);
secondStartFuture.get(TIMEOUT, TIMEOUT_UNIT);
verify(pircBotX, times(2)).startBot();
}
@Test
@SuppressWarnings("unchecked")
public void testSendMessageInBackground() throws Exception {
instance.connect();
String message = "test message";
mockTaskService();
CompletableFuture<String> future =
instance.sendMessageInBackground(DEFAULT_CHANNEL_NAME, message);
assertThat(future.get(TIMEOUT, TIMEOUT_UNIT), is(message));
verify(pircBotX).sendIRC();
verify(outputIrc).message(DEFAULT_CHANNEL_NAME, message);
}
@Test
public void testGetChatUsersForChannelEmpty() throws Exception {
ObservableMap<String, ChatUser> chatUsersForChannel =
instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME);
assertThat(chatUsersForChannel.values(), empty());
}
@Test
public void testGetChatUsersForChannelTwoUsersInDifferentChannel() throws Exception {
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
instance.onUserJoinedChannel(OTHER_CHANNEL_NAME, chatUser2);
ObservableMap<String, ChatUser> chatUsersForDefaultChannel =
instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME);
ObservableMap<String, ChatUser> chatUsersForOtherChannel =
instance.getChatUsersForChannel(OTHER_CHANNEL_NAME);
assertThat(chatUsersForDefaultChannel.values(), hasSize(1));
assertThat(chatUsersForDefaultChannel.values().iterator().next(), sameInstance(chatUser1));
assertThat(chatUsersForOtherChannel.values(), hasSize(1));
assertThat(chatUsersForOtherChannel.values().iterator().next(), sameInstance(chatUser2));
}
@Test
public void testGetChatUsersForChannelTwoUsersInSameChannel() throws Exception {
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser2);
ObservableMap<String, ChatUser> chatUsersForDefaultChannel =
instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME);
assertThat(chatUsersForDefaultChannel.values(), hasSize(2));
assertThat(chatUsersForDefaultChannel.values(), containsInAnyOrder(chatUser1, chatUser2));
}
@Test
public void testAddChannelUserListListener() throws Exception {
@SuppressWarnings("unchecked")
MapChangeListener<String, ChatUser> listener = mock(MapChangeListener.class);
instance.addChannelUserListListener(DEFAULT_CHANNEL_NAME, listener);
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser2);
verify(listener, times(2)).onChanged(any());
}
@Test
public void testLeaveChannel() throws Exception {
OutputChannel outputChannel = mock(OutputChannel.class);
when(userChannelDao.getChannel(DEFAULT_CHANNEL_NAME)).thenReturn(defaultChannel);
when(defaultChannel.send()).thenReturn(outputChannel);
instance.connect();
instance.leaveChannel(DEFAULT_CHANNEL_NAME);
verify(outputChannel).part();
}
@Test
public void testSendActionInBackground() throws Exception {
instance.connect();
String action = "test action";
when(taskService.submitTask(any())).thenReturn(CompletableFuture.completedFuture(action));
mockTaskService();
CompletableFuture<String> future =
instance.sendActionInBackground(DEFAULT_CHANNEL_NAME, action);
verify(pircBotX).sendIRC();
verify(outputIrc).action(DEFAULT_CHANNEL_NAME, action);
assertThat(future.get(TIMEOUT, TIMEOUT_UNIT), is(action));
}
@Ignore("hangs when run with other tests")
@Test
public void testJoinChannel() throws Exception {
CountDownLatch connectedLatch = new CountDownLatch(1);
String channelToJoin = "#anotherChannel";
doAnswer(
invocation -> {
connectedLatch.countDown();
return null;
})
.when(outputIrc)
.joinChannel(DEFAULT_CHANNEL_NAME);
when(taskService.submitTask(any())).thenReturn(CompletableFuture.completedFuture(null));
instance.connect();
instance.connectionStateProperty().set(ConnectionState.CONNECTED);
assertTrue(connectedLatch.await(TIMEOUT, TIMEOUT_UNIT));
instance.joinChannel(channelToJoin);
verify(outputIrc).joinChannel(DEFAULT_CHANNEL_NAME);
verify(outputIrc).joinChannel(channelToJoin);
}
@Test
@SuppressWarnings("unchecked")
public void testAddOnJoinChannelsRequestListener() throws Exception {
Consumer<List<String>> listener = mock(Consumer.class);
instance.addOnJoinChannelsRequestListener(listener);
verify(fafService).addOnMessageListener(eq(SocialMessage.class), any());
}
@Test
public void testIsDefaultChannel() throws Exception {
assertTrue(instance.isDefaultChannel(DEFAULT_CHANNEL_NAME));
}
@Test
public void testOnConnected() throws Exception {
String password = "******";
when(userService.getPassword()).thenReturn(password);
instance.connect();
botStartedFuture.get(TIMEOUT, TIMEOUT_UNIT);
CountDownLatch latch = new CountDownLatch(1);
doAnswer(
invocation -> {
latch.countDown();
return null;
})
.when(outputIrc)
.joinChannel(DEFAULT_CHANNEL_NAME);
mockTaskService();
instance.connectionStateProperty().set(ConnectionState.CONNECTED);
String md5Password = Hashing.md5().hashString(password, StandardCharsets.UTF_8).toString();
verify(outputIrc).message("NICKSERV", String.format("IDENTIFY %s", md5Password));
assertTrue("Channel has not been joined within timeout", latch.await(TIMEOUT, TIMEOUT_UNIT));
}
private String asdf() {
return null;
}
@Test
public void testOnDisconnected() throws Exception {
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
assertThat(instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME).values(), hasSize(1));
instance.connectionStateProperty().set(ConnectionState.DISCONNECTED);
assertThat(instance.getChatUsersForChannel(DEFAULT_CHANNEL_NAME).values(), empty());
}
@Test
public void testOnModeratorSet() throws Exception {
instance.onUserJoinedChannel(DEFAULT_CHANNEL_NAME, chatUser1);
ObservableSet<String> moderatorInChannels =
instance
.getChatUsersForChannel(DEFAULT_CHANNEL_NAME)
.get(chatUser1.getUsername())
.getModeratorInChannels();
assertThat(moderatorInChannels, empty());
instance.onModeratorSet(DEFAULT_CHANNEL_NAME, chatUser1.getUsername());
assertThat(moderatorInChannels, contains(DEFAULT_CHANNEL_NAME));
}
@Test
public void testOnModeratorSetUserNotInChannelDoesntThrowException() throws Exception {
instance.onModeratorSet(DEFAULT_CHANNEL_NAME, chatUser1.getUsername());
}
@Test
public void testClose() {
instance.close();
}
@Test
public void testOnConnectedAutomaticallyRegisters() {}
@Test
public void testCreateOrGetChatUserStringEmptyMap() throws Exception {
when(chatPrefs.getChatColorMode()).thenReturn(chatColorMode.get());
when(chatPrefs.getUserToColor()).thenReturn(userToColorProperty);
ChatUser returnedUser = instance.createOrGetChatUser("chatUser1");
assert returnedUser != chatUser1;
assertEquals(returnedUser, chatUser1);
}
@Test
public void testCreateOrGetChatUserStringPopulatedMap() throws Exception {
when(chatPrefs.getChatColorMode()).thenReturn(chatColorMode.get());
when(chatPrefs.getUserToColor()).thenReturn(userToColorProperty);
ChatUser addedUser = instance.createOrGetChatUser("chatUser1");
ChatUser returnedUser = instance.createOrGetChatUser("chatUser1");
assert returnedUser == addedUser;
assertEquals(returnedUser, addedUser);
}
@Test
public void testCreateOrGetChatUserUserObjectEmptyMap() throws Exception {
when(chatPrefs.getChatColorMode()).thenReturn(chatColorMode.get());
when(chatPrefs.getUserToColor()).thenReturn(userToColorProperty);
ChatUser returnedUser = instance.createOrGetChatUser("chatUser1");
assert returnedUser != chatUser1;
assertEquals(returnedUser, chatUser1);
}
@Test
public void testCreateOrGetChatUserUserObjectPopulatedMap() throws Exception {
when(chatPrefs.getChatColorMode()).thenReturn(chatColorMode.get());
when(chatPrefs.getUserToColor()).thenReturn(userToColorProperty);
ChatUser addedUser = instance.createOrGetChatUser("chatUser1");
ChatUser returnedUser = instance.createOrGetChatUser("chatUser1");
assert returnedUser == addedUser;
assertEquals(returnedUser, addedUser);
}
}
public static void main(String[] args) {
esAddress = InetAddress.getLoopbackAddress();
final Options options = new Options();
options.addOption("h", "help", false, "print this message");
options.addOption(
"A",
"autocorrect",
false,
"enables auto correction:"
+ newline
+ "- try to fix lines with less columns than the header specifies"
+ newline
+ "- if only one date column could be parsed assign this value to both date fields"
+ newline
+ "(for catalog parsing only)");
options.addOption("c", "catalog", false, "parse and import cdfinder/neofinder catalog files");
options.addOption(
"r",
"readerrors",
false,
"ignore read errors" + newline + "(for file system scanning only)");
options.addOption(
"n",
"newindex",
false,
"create a new elasticsearch index "
+ newline
+ "(if an old one with the same name exists it will be deleted)");
options.addOption("v", "verbose", false, "show JSON objects that are added to the index");
options.addOption(
Option.builder("a")
.longOpt("address")
.desc(
"the address of the elasticsearch index "
+ newline
+ "(omitting this the local loopback address will be used)")
.hasArg()
.argName("ADDRESS")
.build());
options.addOption(
Option.builder("i")
.longOpt("indexname")
.desc(
"the name of the elasticsearch index "
+ newline
+ "(omitting this the name '"
+ esIndexName
+ "' will be used)")
.hasArg()
.argName("NAME")
.build());
options.addOption(
Option.builder("I")
.longOpt("ignore")
.desc(
"the field or fields to ignore potentially invalid data for"
+ newline
+ "if multiple fields are specified they must be comma separated"
+ newline
+ "(use with care as this may create records that will miss the specified fields)"
+ newline
+ "(for catalog parsing only)")
.hasArgs()
.valueSeparator(',')
.argName("FIELDLIST")
.build());
options.addOption(
Option.builder("e")
.longOpt("esclustername")
.desc(
"the name of the elasticsearch cluster "
+ newline
+ "(omitting this the default name 'elasticsearch' will be used)")
.hasArg()
.argName("NAME")
.build());
options.addOption(
Option.builder("m")
.longOpt("mimetype")
.desc(
"the mime type fetch strategy to use:"
+ newline
+ "0: no mime type information is fetched (default)"
+ newline
+ "1: mime type is 'guessed' based on file extension"
+ newline
+ "2: mime type is detected by inspecting the file (most accurate but slow)"
+ newline
+ "(for file system scanning only)")
.hasArg()
.argName("STRATEGY")
.build());
options.addOption(
Option.builder()
.longOpt("iknowiamonlyimportingpathandvolume")
.desc("import only path and volume" + newline + "(for catalog parsing only)")
.build());
String address = "";
List<String> argList = null;
try {
final CommandLineParser parser = new DefaultParser();
final CommandLine cmd = parser.parse(options, args);
argList = cmd.getArgList();
if (!argList.isEmpty()) {
scanMode = !cmd.hasOption("c");
autoCorrect = !scanMode && cmd.hasOption("A");
minimalImport = !scanMode && cmd.hasOption("iknowiamonlyimportingpathandvolume");
verbose = cmd.hasOption("v");
if (cmd.hasOption("a")) {
address = cmd.getOptionValue("a");
esAddress = InetAddress.getByName(address);
}
if (cmd.hasOption("e")) {
esClusterName = cmd.getOptionValue("e");
}
if (cmd.hasOption("i")) {
esIndexName = cmd.getOptionValue("i");
}
if (scanMode && cmd.hasOption("m")) {
mimeInfo = Integer.valueOf(cmd.getOptionValue("m"));
}
if (!scanMode && cmd.hasOption("I")) {
ignoreFields = Arrays.stream(cmd.getOptionValues("I")).collect(Collectors.toSet());
Map<String, List<String>> tokenMap = Mapping.getTokenMap();
for (String field : ignoreFields) {
if (!tokenMap.containsKey(field)) {
System.out.println("Unknown field '" + field + "'.");
System.exit(4);
}
}
}
} else {
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp(
"neofindertoes [options] FILE_OR_DIRECTORY1 [FILE_OR_DIRECTORY2 "
+ "[FILE_OR_DIRECTORY3] ...]\nOptions:",
options);
System.exit(0);
}
esService = new ESService(esAddress, esClusterName, esIndexName);
System.out.println(
"Elasticsearch cluster: " + esAddress.toString() + " [" + esClusterName + ']');
if (esService.isClusterAvailable()) {
if (cmd.hasOption("n")) {
if (esService.indexExists()) {
esService.deleteIndex();
}
if (!esService.createIndex()) {
System.out.println("Failed to create elasticsearch index");
System.exit(3);
}
System.out.println("Adding to newly created index '" + esIndexName + "'\n");
} else {
if (!esService.indexExists()) {
if (!esService.createIndex()) {
System.out.println("Failed to create elasticsearch index");
System.exit(3);
}
}
System.out.println("Adding to existing index '" + esIndexName + "'\n");
}
} else {
System.exit(7);
}
} catch (ParseException ex) {
if (ex instanceof UnrecognizedOptionException) {
System.out.println(ex.getMessage());
System.exit(1);
}
System.out.println("Failed to parse command line options.\n" + ex.getMessage());
System.exit(2);
} catch (UnknownHostException ex) {
System.out.println("Host '" + address + "' not found.");
System.exit(6);
}
final ProgressRotating progressIndicator = new ProgressRotating();
for (String filename : argList) {
try {
File scanDirectory = new File(filename).getCanonicalFile();
if (!scanDirectory.exists()) {
System.err.println("Source '" + filename + "' does not exist.");
continue;
}
if (!progressIndicator.isAlive()) {
progressIndicator.start();
}
if (scanDirectory.isDirectory()) {
if (scanMode) {
new FileSystemScanner(esService).scan(scanDirectory, maxThreads, mimeInfo, verbose);
} else {
String[] files = scanDirectory.list();
for (final String file : files) {
new CsvReader(esService, verbose, progressIndicator)
.read(scanDirectory + "/" + file, autoCorrect, ignoreFields, minimalImport);
}
}
} else {
if (!scanMode) {
new CsvReader(esService, verbose, progressIndicator)
.read(scanDirectory.getAbsolutePath(), autoCorrect, ignoreFields, minimalImport);
}
}
} catch (IOException ex) {
System.out.println("Could not read '" + filename + "'.");
}
}
esService.close();
if (progressIndicator.isAlive()) {
progressIndicator.terminate();
}
}
/** A builder providing a fluent way of defining EmbeddedLdapRule instances */
public class EmbeddedLdapRuleBuilder {
public static final String DEFAULT_DOMAIN = "dc=example,dc=com";
public static final String DEFAULT_BIND_DSN = "cn=Directory manager";
public static final String DEFAULT_BIND_CREDENTIALS = "password";
public static final String LDAP_SERVER_LISTENER_NAME = "test-listener";
public static final int MIN_PORT_EXCLUSIVE = 0;
public static final int MAX_PORT_EXCLUSIVE = 65535;
private List<String> domainDsn = new LinkedList<>();
private String bindDSN = DEFAULT_BIND_DSN;
private String bindCredentials = DEFAULT_BIND_CREDENTIALS;
private List<String> ldifsToImport = new LinkedList<>();
private List<String> schemaLdifs = new LinkedList<>();
private boolean addDefaultSchema = true;
private Integer bindPort = 0;
private InetAddress bindAddress = InetAddress.getLoopbackAddress();
private AuthenticationConfiguration authenticationConfiguration;
public EmbeddedLdapRuleBuilder() {}
/**
* Creates a new builder
*
* @return a new EmbeddedLdapRuleBuilder instance
*/
public static EmbeddedLdapRuleBuilder newInstance() {
return new EmbeddedLdapRuleBuilder();
}
/**
* Sets a domainDsn to be used. May be multiple values. If not set, it will default to the value
* of the {@link #DEFAULT_DOMAIN DEFAULT_DOMAIN} field
*
* @param domainDsn a valid DSN string
* @return same EmbeddedLdapRuleBuilder instance with the domainDsn field set
*/
public EmbeddedLdapRuleBuilder usingDomainDsn(final String domainDsn) {
this.domainDsn.add(domainDsn);
return this;
}
/**
* Sets the DSN to bind to when authenticating. If not set, it will default to the value of the
* {@link #DEFAULT_BIND_DSN DEFAULT_BIND_DSN} field
*
* @param bindDSN a valid DSN string
* @return same EmbeddedLdapRuleBuilder instance with the bindDSN field set
*/
public EmbeddedLdapRuleBuilder usingBindDSN(final String bindDSN) {
this.bindDSN = bindDSN;
return this;
}
/**
* Sets the credentials to be used to authenticate. If not set, it will default to the value of
* the {@link #DEFAULT_BIND_CREDENTIALS DEFAULT_BIND_CREDENTIALS} field
*
* @param bindCredentials a password string
* @return same EmbeddedLdapRuleBuilder instance with the bindCredentials field set
*/
public EmbeddedLdapRuleBuilder usingBindCredentials(final String bindCredentials) {
this.bindCredentials = bindCredentials;
return this;
}
/**
* Sets the port that the in-memory LDAP server will bind to. If not set, an available port will
* be picked automatically
*
* @param port a port number
* @return same EmbeddedLdapRuleBuilder instance with the port field set
* @throws IllegalArgumentException if the provided value for port is not between @{link
* MIN_PORT_EXCLUSIVE} and @{MAX_PORT_EXCLUSIVE} (exclusive)
*/
public EmbeddedLdapRuleBuilder bindingToPort(final int port) {
if ((port < MIN_PORT_EXCLUSIVE) || (port > MAX_PORT_EXCLUSIVE)) {
throw new IllegalArgumentException(
String.format("Value \"%s\" is not a valid port number", port));
}
this.bindPort = Integer.valueOf(port);
return this;
}
/**
* Allows the listening address for the embedded LDAP server to be set. If not set it will bind to
* <em>localhost/127.0.0.1</em>.
*
* @param address a valid hostname or textual representation of an IP address
* @return same EmbeddedLdapRuleBuilder instance with the bindAddress field set
* @throws IllegalArgumentException if the value provided for \"address\" is invalid
*/
public EmbeddedLdapRuleBuilder bindingToAddress(final String address) {
Objects.requireNonNull(address);
try {
final InetAddress addressByName = InetAddress.getByName(address);
this.bindAddress = addressByName;
} catch (UnknownHostException e) {
throw new IllegalArgumentException(String.format("Unknown host address \"%s\"", address), e);
}
return this;
}
/**
* Avoid adding UnboundID's default schema that contains the most common LDAP elements defined
* through various RFC's.
*
* @return same EmbeddedLdapRuleBuilder instance with the withoutDefaultSchema field set to FALSE
*/
public EmbeddedLdapRuleBuilder withoutDefaultSchema() {
this.addDefaultSchema = false;
return this;
}
/**
* Define schemas to be used for the server. If not defined, UnboundID will set up a default
* schema.
*
* @param ldifSchemaFiles LDIF-files containing schema element definitions
* @return same EmbeddedLdapRuleBuilder with the given LDIF-files added to the internal schema
* file collection.
*/
public EmbeddedLdapRuleBuilder withSchema(final String... ldifSchemaFiles) {
this.schemaLdifs.addAll(Arrays.asList(ldifSchemaFiles));
return this;
}
/**
* Specify one or more LDIF resources to be imported on startup.
*
* @param ldifFiles LDIF-files to import
* @return same EmbeddedLdapRuleBuilder instance with the provided ldifFiles added to the list of
* LDIF files to import
*/
public EmbeddedLdapRuleBuilder importingLdifs(final String... ldifFiles) {
if (ldifFiles != null) {
ldifsToImport.addAll(Arrays.asList(ldifFiles));
}
return this;
}
/**
* Creates a new rule based on the information that was previously provided
*
* @return a new EmbeddedLdapRule instance
*/
public EmbeddedLdapRule build() {
Objects.requireNonNull(bindDSN, "\"bindDSN\" can not be null");
return EmbeddedLdapRuleImpl.createForConfiguration(
createInMemoryServerConfiguration(), authenticationConfiguration, ldifsToImport);
}
private InMemoryDirectoryServerConfig createInMemoryServerConfiguration() {
try {
final InMemoryDirectoryServerConfig inMemoryDirectoryServerConfig =
new InMemoryDirectoryServerConfig(domainDsnArray());
if (bindCredentials != null) {
this.authenticationConfiguration =
new AuthenticationConfiguration(bindDSN, bindCredentials);
inMemoryDirectoryServerConfig.addAdditionalBindCredentials(bindDSN, bindCredentials);
}
final InMemoryListenerConfig listenerConfig =
InMemoryListenerConfig.createLDAPConfig(
LDAP_SERVER_LISTENER_NAME, bindAddress, bindPort, null);
inMemoryDirectoryServerConfig.setListenerConfigs(listenerConfig);
for (Schema s : customSchema().asSet()) {
inMemoryDirectoryServerConfig.setSchema(s);
}
return inMemoryDirectoryServerConfig;
} catch (LDAPException e) {
throw new IllegalStateException(
"Could not create configuration for the in-memory LDAP instance due to an exception", e);
}
}
private String[] domainDsnArray() {
if (domainDsn.size() == 0) {
return new String[] {DEFAULT_DOMAIN};
} else {
return domainDsn.toArray(new String[] {});
}
}
private Optional<Schema> customSchema() {
final List<File> schemaFiles = schemaFiles();
try {
final Schema initialSchema = (addDefaultSchema ? Schema.getDefaultStandardSchema() : null);
if (!schemaFiles.isEmpty()) {
final Schema customSchema =
initialSchema == null
? Schema.getSchema(schemaFiles)
: Schema.mergeSchemas(initialSchema, Schema.getSchema(schemaFiles));
return Optional.fromNullable(customSchema);
} else {
return Optional.absent();
}
} catch (IOException | LDIFException | LDAPException e) {
throw new IllegalArgumentException(
"Could not create custom LDAP schema due, probably caused by an incorrectly formatted schema",
e);
}
}
private List<File> schemaFiles() {
return Lists.newArrayList(
Lists.transform(
this.schemaLdifs,
new Function<String, File>() {
@Override
public File apply(final String input) {
try {
final File file = new File(Resources.getResource(input).toURI());
if (!file.isFile()) {
throw new IllegalArgumentException(
String.format(
"The resource named \"%s\" can not be found or is not a file", input));
}
return file;
} catch (URISyntaxException e) {
throw new IllegalArgumentException(
String.format(
"The resource named \"%s\" is not a valid file reference", input),
e);
}
}
}));
}
}