public ContainerOptionsBuilder withAwaitStrategy(Await awaitStrategy) { cubeContainer.setAwait(awaitStrategy); return this; }
public ContainerOptionsBuilder withAwaitStrategy(Await awaitStrategy) { cubeContainer.setAwait(awaitStrategy); return this; }
private static void setDefaultSeleniumCubeProperties(CubeContainer cubeContainer, int seleniumBoundedPort) { final ArrayList<PortBinding> portBindings = new ArrayList<>(); portBindings.add(PortBinding.valueOf(seleniumBoundedPort + "->4444")); final Image image = cubeContainer.getImage(); if (null != image && image.getName().toLowerCase().contains("debug")) { //Expose VNC portBindings.add(PortBinding.valueOf("5900->5900")); } cubeContainer.setPortBindings( portBindings ); Await await = new Await(); await.setStrategy("http"); await.setResponseCode(getSeleniumExpectedResponseCode()); await.setUrl("http://dockerHost:" + seleniumBoundedPort); cubeContainer.setAwait(await); cubeContainer.setKillContainer(true); }
private static void setDefaultSeleniumCubeProperties(CubeContainer cubeContainer, int seleniumBoundedPort) { cubeContainer.setPortBindings( Arrays.asList(PortBinding.valueOf(seleniumBoundedPort + "-> 4444")) ); Await await = new Await(); await.setStrategy("http"); await.setResponseCode(getSeleniumExpectedResponseCode()); await.setUrl("http://dockerHost:" + seleniumBoundedPort); cubeContainer.setAwait(await); cubeContainer.setKillContainer(true); }
private static CubeContainer createVncContainer(final Path dockerVolume, String seleniumContainerName) { CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setImage(Image.valueOf(VNC_IMAGE)); cubeContainer.setBinds( Arrays.asList(convertToBind(dockerVolume, VOLUME_DIR, "Z")) ); final Link link = Link.valueOf(seleniumContainerName + ":" + VNC_HOSTNAME); cubeContainer.setLinks(Arrays.asList(link)); // Using sleeping strategy since VNC client is a CLI without exposing a port Await await = new Await(); await.setStrategy("sleeping"); await.setSleepTime("100 ms"); cubeContainer.setAwait(await); cubeContainer.setCmd(Arrays.asList(FLVREC_COMMAND)); // sets container as manual because we need to start and stop for each test case cubeContainer.setManual(true); return cubeContainer; }
private static CubeContainer createVncContainer(final Path dockerVolume, String seleniumContainerName, String dockerRegistry) { CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setImage(Image.valueOf(dockerRegistry + VNC_IMAGE)); cubeContainer.setBinds( Arrays.asList(convertToBind(dockerVolume, VOLUME_DIR, "Z")) ); final Link link = Link.valueOf(seleniumContainerName + ":" + VNC_HOSTNAME); cubeContainer.setLinks(Arrays.asList(link)); // Using sleeping strategy since VNC client is a CLI without exposing a port Await await = new Await(); await.setStrategy("sleeping"); await.setSleepTime("100 ms"); cubeContainer.setAwait(await); cubeContainer.setCmd(Arrays.asList(FLVREC_COMMAND)); // sets container as manual because we need to start and stop for each test case cubeContainer.setManual(true); return cubeContainer; }
private static CubeContainer createVideoConverterContainer(Path dockerVolume, String dockerRegistry) { CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setImage(Image.valueOf(dockerRegistry + CONVERSION_IMAGE)); cubeContainer.setBinds( Arrays.asList(convertToBind(dockerVolume, VOLUME_DIR, "Z")) ); // Using log await strategy to match the echo string indicating completion of conversion Await await = new Await(); await.setStrategy("log"); await.setMatch("CONVERSION COMPLETED"); cubeContainer.setAwait(await); // sets container as manual because we need to start and stop cubeContainer.setManual(true); return cubeContainer; }
private static CubeContainer createVideoConverterContainer(Path dockerVolume) { CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setImage(Image.valueOf(CONVERSION_IMAGE)); cubeContainer.setBinds( Arrays.asList(convertToBind(dockerVolume, VOLUME_DIR, "Z")) ); // Using log await strategy to match the echo string indicating completion of conversion Await await = new Await(); await.setStrategy("log"); await.setMatch("CONVERSION COMPLETED"); cubeContainer.setAwait(await); // sets container as manual because we need to start and stop cubeContainer.setManual(true); return cubeContainer; }
@Test public void should_create_polling_await_strategy() { Await await = new Await(); await.setStrategy("polling"); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(PollingAwaitStrategy.class)); }
@Test public void should_create_native_await_strategy() { Await await = new Await(); await.setStrategy("native"); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(NativeAwaitStrategy.class)); }
@Test public void should_create_static_await_strategy() { Await await = new Await(); await.setStrategy("static"); await.setIp("localhost"); await.setPorts(Arrays.asList(8080, 8089)); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(StaticAwaitStrategy.class)); StaticAwaitStrategy staticAwaitStrategy = (StaticAwaitStrategy) strategy; assertThat(staticAwaitStrategy.getIp(), is("localhost")); assertThat(staticAwaitStrategy.getPorts().get(0), is(8080)); assertThat(staticAwaitStrategy.getPorts().get(1), is(8089)); }
@Test public void should_be_able_to_create_custom_await_strategies() { Await await = new Await(); await.setStrategy("org.arquillian.cube.docker.impl.await.CustomAwaitStrategyImpl"); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(dockerClientExecutor, cube, cubeContainer); assertThat(strategy, instanceOf(CustomAwaitStrategyInstantiator.class)); CustomAwaitStrategyInstantiator customAwaitStrategyInstantiator = (CustomAwaitStrategyInstantiator) strategy; assertThat(customAwaitStrategyInstantiator.await(), is(true)); }
@Test public void should_create_sleeping_await_strategy_with_specific_times() { Await await = new Await(); await.setStrategy("sleeping"); await.setSleepTime("200 s"); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(SleepingAwaitStrategy.class)); assertThat(((SleepingAwaitStrategy) strategy).getSleepTime(), is(200)); }
@Test public void should_create_polling_await_strategy_with_specific_port() { Await await = new Await(); await.setStrategy("polling"); await.setPorts(Arrays.asList(80)); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(PollingAwaitStrategy.class)); assertThat(((PollingAwaitStrategy) strategy).getPorts(), hasItems(80)); }
@Test public void should_create_polling_await_strategy_with_specific_times() { Await await = new Await(); await.setStrategy("polling"); await.setSleepPollingTime(200); await.setIterations(3); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(PollingAwaitStrategy.class)); assertThat(((PollingAwaitStrategy) strategy).getPollIterations(), is(3)); assertThat(((PollingAwaitStrategy) strategy).getSleepTime(), is(200)); }
@Test public void should_create_log_scanning_await_strategy() { Await await = new Await(); await.setStrategy("log"); await.setMatch("STARTED"); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(LogScanningAwaitStrategy.class)); final LogScanningAwaitStrategy log = (LogScanningAwaitStrategy) strategy; assertThat(log.getTimeout(), is(15)); assertThat(log.isStdOut(), is(true)); assertThat(log.isStdErr(), is(false)); }
@Test public void should_create_static_await_strategy_without_defaults_and_units() { Await await = new Await(); await.setStrategy("static"); await.setIp("localhost"); await.setPorts(Arrays.asList(8080, 8089)); await.setSleepPollingTime("200 s"); await.setIterations(3); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(StaticAwaitStrategy.class)); StaticAwaitStrategy staticAwaitStrategy = (StaticAwaitStrategy) strategy; assertThat(staticAwaitStrategy.getIp(), is("localhost")); assertThat(staticAwaitStrategy.getPorts().get(0), is(8080)); assertThat(staticAwaitStrategy.getPorts().get(1), is(8089)); assertThat(staticAwaitStrategy.getPollIterations(), is(3)); assertThat(staticAwaitStrategy.getSleepTime(), is(200)); assertThat(staticAwaitStrategy.getTimeUnit(), is(TimeUnit.SECONDS)); }
@Test public void should_create_polling_await_strategy_with_specific_times_and_unit() { Await await = new Await(); await.setStrategy("polling"); await.setSleepPollingTime("200 s"); await.setIterations(3); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(PollingAwaitStrategy.class)); assertThat(((PollingAwaitStrategy) strategy).getPollIterations(), is(3)); assertThat(((PollingAwaitStrategy) strategy).getSleepTime(), is(200)); assertThat(((PollingAwaitStrategy) strategy).getTimeUnit(), is(TimeUnit.SECONDS)); assertThat(((PollingAwaitStrategy) strategy).getType(), is("sscommand")); }
@Test public void should_create_polling_await_strategy_with_specific_type() { Await await = new Await(); await.setStrategy("polling"); await.setType("sscommand"); await.setSleepPollingTime("200 s"); await.setIterations(3); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(PollingAwaitStrategy.class)); assertThat(((PollingAwaitStrategy) strategy).getType(), is("sscommand")); }
@Test public void should_create_log_scanning_await_strategy_without_defaults() { Await await = new Await(); await.setStrategy("log"); await.setMatch("regexp:.*STARTED.*"); await.setStdOut(false); await.setStdErr(true); await.setTimeout(20); await.setOccurrences(3); CubeContainer cubeContainer = new CubeContainer(); cubeContainer.setAwait(await); AwaitStrategy strategy = AwaitStrategyFactory.create(null, cube, cubeContainer); assertThat(strategy, instanceOf(LogScanningAwaitStrategy.class)); final LogScanningAwaitStrategy log = (LogScanningAwaitStrategy) strategy; assertThat(log.getTimeout(), is(20)); assertThat(log.isStdOut(), is(false)); assertThat(log.isStdErr(), is(true)); assertThat(log.getOccurrences(), is(3)); }