@Test public void tlsVerifyShouldBeFalseInCaseOfSetToTrueAndHttpServerUri() { Map<String, String> config = new HashMap<>(); config.put(CubeDockerConfiguration.DOCKER_URI, "http://192.168.0.2:22222"); config.put(CubeDockerConfiguration.TLS_VERIFY, "true"); when(extensionDef.getExtensionProperties()).thenReturn(config); when(arquillianDescriptor.extension("docker")).thenReturn(extensionDef); when(commandLineExecutor.execCommand("docker-machine")).thenThrow(new RuntimeException()); fire(new CubeConfiguration()); assertThat(config, hasEntry(CubeDockerConfiguration.DOCKER_URI, "tcp://192.168.0.2:22222")); assertThat(config, hasEntry(CubeDockerConfiguration.TLS_VERIFY, "false")); assertThat(config, not(hasKey(CubeDockerConfiguration.CERT_PATH))); }
public void configure(@Observes(precedence = -10) ArquillianDescriptor arquillianDescriptor) { Map<String, String> config = arquillianDescriptor.extension(EXTENSION_NAME).getExtensionProperties(); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(config); configurationProducer.set(cubeConfiguration); } }
@Test public void shouldCreateAndStartAutoContainersWhenNoAutoStartIsProvided() { Map<String, String> dockerData = new HashMap<String, String>(); dockerData.put("dockerContainers", "a:\n image: a\n links:\n - b:b\nb:\n image: a\n"); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(new HashMap<String, String>()); bind(ApplicationScoped.class, CubeConfiguration.class, cubeConfiguration); CubeDockerConfiguration dockerConfiguration = CubeDockerConfiguration.fromMap(dockerData, null); dockerConfiguration.setAutoStartContainers(new AutomaticResolutionLinksAutoStartParser(Arrays.asList("a"), dockerConfiguration.getDockerContainersContent())); bind(ApplicationScoped.class, CubeDockerConfiguration.class, dockerConfiguration); ContainerRegistry containerRegistry = mock(ContainerRegistry.class); List<org.jboss.arquillian.container.spi.Container> containers = new ArrayList<>(); org.jboss.arquillian.container.spi.Container container = mock(org.jboss.arquillian.container.spi.Container.class); when(container.getName()).thenReturn("a"); containers.add(container); when(containerRegistry.getContainers()).thenReturn(containers); bind(ApplicationScoped.class, ContainerRegistry.class, containerRegistry); fire(new BeforeSuite()); assertEventFired(CreateCube.class, 1); assertEventFired(StartCube.class, 1); }
@Test public void shouldStartDockerMachineIfItIsStoppedAndMachineNameIsSet() { Map<String, String> config = new HashMap<>(); config.put(CubeDockerConfiguration.DOCKER_URI, "tcp://dockerHost:22222"); config.put(CubeDockerConfiguration.DOCKER_MACHINE_NAME, "dev"); when(extensionDef.getExtensionProperties()).thenReturn(config); when(arquillianDescriptor.extension("docker")).thenReturn(extensionDef); when(commandLineExecutor.execCommandAsArray("docker-machine", "ls")) .thenReturn(Arrays.asList( "NAME ACTIVE DRIVER STATE URL SWARM", "dev * virtualbox Stopped tcp://192.168.0.2:222222 ")); when(commandLineExecutor.execCommand("docker-machine", "ip", "dev")).thenReturn("192.168.0.2"); fire(new CubeConfiguration()); assertThat(config, hasEntry(CubeDockerConfiguration.DOCKER_URI, "tcp://192.168.0.2:22222")); verify(commandLineExecutor, times(1)).execCommand("docker-machine", "start", "dev"); }
@Before public void setup() { when(cube.getId()).thenReturn(CUBE_ID); CubeRegistry registry = new LocalCubeRegistry(); registry.addCube(cube); bind(ApplicationScoped.class, CubeRegistry.class, registry); CubeConfiguration configuration = CubeConfiguration.fromMap(new HashMap<String, String>()); fire(configuration); }
@Test public void shouldStartNetworks() { DockerClientExecutor executor = Mockito.mock(DockerClientExecutor.class); String config = "networks:\n" + " mynetwork:\n " + " driver: bridge\n" + "tomcat6:\n" + " image: tutum/tomcat:6.0\n" + " exposedPorts: [8089/tcp]\n" + " await:\n" + " strategy: static\n" + " ip: localhost\n" + " ports: [8080, 8089]\n" + "tomcat7:\n" + " extends: tomcat6\n" + " image: tutum/tomcat:7.0\n"; Map<String, String> parameters = new HashMap<String, String>(); parameters.put("dockerContainers", config); parameters.put("definitionFormat", DefinitionFormat.CUBE.name()); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(new HashMap<String, String>()); bind(ApplicationScoped.class, CubeConfiguration.class, cubeConfiguration); CubeDockerConfiguration dockerConfiguration = CubeDockerConfiguration.fromMap(parameters, null); bind(ApplicationScoped.class, CubeDockerConfiguration.class, dockerConfiguration); final LocalDockerNetworkRegistry localDockerNetworkRegistry = new LocalDockerNetworkRegistry(); bind(ApplicationScoped.class, NetworkRegistry.class, localDockerNetworkRegistry); bind(ApplicationScoped.class, DockerClientExecutor.class, executor); fire(new BeforeSuite()); Mockito.verify(executor).createNetwork(Matchers.eq("mynetwork"), Matchers.any(Network.class)); }
@Before @SuppressWarnings("unchecked") public void setup() { when(cube.getId()).thenReturn(CUBE_ID); when(container.getName()).thenReturn(CUBE_ID); when(container.getDeployableContainer()).thenReturn(deployableContainer); when(container.getContainerConfiguration()).thenReturn(containerDef); when(containerDef.getContainerProperties()).thenReturn(Collections.EMPTY_MAP); when(containerRegistry.getContainers()).thenReturn(Arrays.asList(container)); registry = new LocalCubeRegistry(); registry.addCube(cube); bind(ApplicationScoped.class, CubeRegistry.class, registry); bind(ApplicationScoped.class, ContainerRegistry.class, containerRegistry); bind(ApplicationScoped.class, CubeConfiguration.class, new CubeConfiguration()); }
@Test public void shouldParseEmptyAutostart() throws Exception { Map<String, String> parameters = new HashMap<String, String>(); parameters.put("autoStartContainers", ""); parameters.put("dockerContainers", "a:\n image: a\nb:\n image: a\n"); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(new HashMap<String, String>()); bind(ApplicationScoped.class, CubeConfiguration.class, cubeConfiguration); CubeDockerConfiguration dockerConfiguration = CubeDockerConfiguration.fromMap(parameters, null); bind(ApplicationScoped.class, CubeDockerConfiguration.class, dockerConfiguration); fire(new BeforeSuite()); assertEventFired(CreateCube.class, 0); assertEventFired(StartCube.class, 0); }
public static CubeConfiguration fromMap(Map<String, String> map) { CubeConfiguration cubeConfiguration = new CubeConfiguration(); if (map.containsKey(CONNECTION_MODE)) { cubeConfiguration.connectionMode = ConnectionMode.valueOf(ConnectionMode.class, map.get(CONNECTION_MODE)); } return cubeConfiguration; }
public void startAutoContainers(@Observes(precedence = 100) BeforeSuite event, CubeConfiguration cubeConfiguration, CubeDockerConfiguration dockerConfiguration) { beforeAutoStartEvent.fire(new BeforeAutoStart()); final DockerAutoStartOrder dockerAutoStartOrder = dockerConfiguration.getDockerAutoStartOrder(); List<String[]> autoStartSteps = dockerAutoStartOrder.getAutoStartOrder(dockerConfiguration); startAllSteps(autoStartSteps, cubeConfiguration.getConnectionMode()); afterAutoStartEvent.fire(new AfterAutoStart()); }
@Test public void shouldStartAContainerInStartOrConnectModeAndStopIt() { Map<String, String> cubeData = new HashMap<String, String>(); cubeData.put("connectionMode", ConnectionMode.STARTORCONNECT.name()); Map<String, String> dockerData = new HashMap<String, String>(); dockerData.put("autoStartContainers", "a,b"); dockerData.put("dockerContainers", "a:\n image: a\nb:\n image: a\n"); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(cubeData); bind(ApplicationScoped.class, CubeConfiguration.class, cubeConfiguration); CubeDockerConfiguration dockerConfiguration = CubeDockerConfiguration.fromMap(dockerData, null); bind(ApplicationScoped.class, CubeDockerConfiguration.class, dockerConfiguration); Container container = mock(Container.class); when(container.getNames()).thenReturn(new String[] {"alreadyrun"}); when(executor.listRunningContainers()).thenReturn(Arrays.asList(container)); bind(ApplicationScoped.class, DockerClientExecutor.class, executor); fire(new BeforeSuite()); assertEventFired(CreateCube.class, 2); assertEventFired(StartCube.class, 2); assertEventFired(PreRunningCube.class, 0); assertEventFiredOnOtherThread(CreateCube.class); assertEventFiredOnOtherThread(StartCube.class); }
@Test public void shouldUsePreRunningContainerInStartOrConnectMode() { Map<String, String> data = new HashMap<String, String>(); data.put("connectionMode", ConnectionMode.STARTORCONNECT.name()); bind(ApplicationScoped.class, CubeConfiguration.class, CubeConfiguration.fromMap(data)); when(cube.isRunningOnRemote()).thenReturn(true); fire(new BeforeStart(deployableContainer)); assertEventFired(PreRunningCube.class, 1); }
@Test public void shouldStopNetworks() { DockerClientExecutor executor = Mockito.mock(DockerClientExecutor.class); parameters.put("definitionFormat", DefinitionFormat.CUBE.name()); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(new HashMap<String, String>()); bind(ApplicationScoped.class, CubeConfiguration.class, cubeConfiguration); Mockito.verify(executor).removeNetwork(Matchers.eq("mynetwork"));
@Test public void shouldParseEmptyValuesAutostart() throws Exception { Map<String, String> parameters = new HashMap<String, String>(); parameters.put("autoStartContainers", " , "); parameters.put("dockerContainers", "a:\n image: a\nb:\n image: a\n"); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(new HashMap<String, String>()); bind(ApplicationScoped.class, CubeConfiguration.class, cubeConfiguration); CubeDockerConfiguration dockerConfiguration = CubeDockerConfiguration.fromMap(parameters, null); bind(ApplicationScoped.class, CubeDockerConfiguration.class, dockerConfiguration); fire(new BeforeSuite()); assertEventFired(CreateCube.class, 0); assertEventFired(StartCube.class, 0); }
public static CubeConfiguration fromMap(Map<String, String> map) { CubeConfiguration cubeConfiguration = new CubeConfiguration(); if (map.containsKey(CONNECTION_MODE)) { cubeConfiguration.connectionMode = ConnectionMode.valueOf(ConnectionMode.class, map.get(CONNECTION_MODE)); } return cubeConfiguration; }
public void startAutoContainers(@Observes(precedence = 100) BeforeSuite event, CubeConfiguration cubeConfiguration, CubeDockerConfiguration dockerConfiguration) { beforeAutoStartEvent.fire(new BeforeAutoStart()); final DockerAutoStartOrder dockerAutoStartOrder = dockerConfiguration.getDockerAutoStartOrder(); List<String[]> autoStartSteps = dockerAutoStartOrder.getAutoStartOrder(dockerConfiguration); startAllSteps(autoStartSteps, cubeConfiguration.getConnectionMode()); afterAutoStartEvent.fire(new AfterAutoStart()); }
@Test public void shouldUsePreRunningContainers() { Map<String, String> cubeData = new HashMap<String, String>(); cubeData.put("connectionMode", ConnectionMode.STARTORCONNECT.name()); Map<String, String> dockerData = new HashMap<String, String>(); dockerData.put("autoStartContainers", "a,b"); dockerData.put("dockerContainers", "a:\n image: a\nb:\n image: a\n"); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(cubeData); bind(ApplicationScoped.class, CubeConfiguration.class, cubeConfiguration); CubeDockerConfiguration dockerConfiguration = CubeDockerConfiguration.fromMap(dockerData, null); bind(ApplicationScoped.class, CubeDockerConfiguration.class, dockerConfiguration); Container container = mock(Container.class); when(container.getNames()).thenReturn(new String[] {"a"}); when(executor.listRunningContainers()).thenReturn(Arrays.asList(container)); bind(ApplicationScoped.class, DockerClientExecutor.class, executor); fire(new BeforeSuite()); assertEventFired(CreateCube.class, 1); assertEventFired(StartCube.class, 1); assertEventFired(PreRunningCube.class, 1); assertEventFiredOnOtherThread(CreateCube.class); assertEventFiredOnOtherThread(StartCube.class); assertEventFiredOnOtherThread(PreRunningCube.class); }
@Test public void shouldChangeServerUriInCaseOfRunningDockerInsideDocker() { Map<String, String> config = new HashMap<>(); config.put(CubeDockerConfiguration.DOCKER_URI, "https://dockerHost:22222"); when(extensionDef.getExtensionProperties()).thenReturn(config); when(arquillianDescriptor.extension("docker")).thenReturn(extensionDef); when(commandLineExecutor.execCommand("boot2docker", "ip")).thenReturn("192.168.0.1"); when(commandLineExecutor.execCommand("docker-machine")).thenThrow(new RuntimeException()); when(top.isSpinning()).thenReturn(true); fire(new CubeConfiguration()); assertThat(config, hasEntry(CubeDockerConfiguration.DOCKER_URI, OperatingSystemFamily.DIND.getServerUri())); }
@Test public void shouldStartAContainerInStartOrConnectLeaveModeAndNotStopIt() { Map<String, String> data = new HashMap<String, String>(); data.put("connectionMode", ConnectionMode.STARTORCONNECTANDLEAVE.name()); bind(ApplicationScoped.class, CubeConfiguration.class, CubeConfiguration.fromMap(data)); when(cube.isRunningOnRemote()).thenReturn(false); fire(new BeforeStart(deployableContainer)); assertEventFired(CreateCube.class, 1); assertEventFired(StartCube.class, 1); assertEventFired(PreRunningCube.class, 1); }
public void configure(@Observes(precedence = -10) ArquillianDescriptor arquillianDescriptor) { Map<String, String> config = arquillianDescriptor.extension(EXTENSION_NAME).getExtensionProperties(); CubeConfiguration cubeConfiguration = CubeConfiguration.fromMap(config); configurationProducer.set(cubeConfiguration); } }