| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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 org.apache.sling.pipes; |
| |
| import org.apache.commons.collections.CollectionUtils; |
| import org.apache.sling.api.resource.ValueMap; |
| import org.apache.sling.pipes.internal.JsonUtil; |
| import org.junit.Test; |
| |
| import javax.json.JsonArray; |
| import javax.json.JsonObject; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.stream.Collectors; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| |
| public class PipeBuilderTest extends AbstractPipeTest { |
| @Test |
| public void simpleBuild() throws Exception { |
| PipeBuilder rmBuilder = plumber.newPipe(context.resourceResolver()); |
| Pipe rmPipe = rmBuilder.echo(PATH_APPLE).rm().build(); |
| assertNotNull(" a basePipe should be built", rmPipe); |
| //we rebuild basePipe out of created basePipe path, execute it, and test correct output (= correct basePipe built) |
| testOneResource(rmPipe.getResource().getPath(), PATH_FRUITS); |
| } |
| |
| @Test |
| public void run() throws Exception { |
| String lemonPath = "/content/fruits/lemon"; |
| PipeBuilder lemonBuilder = plumber.newPipe(context.resourceResolver()); |
| ExecutionResult result = lemonBuilder.mkdir(lemonPath).run(); |
| assertTrue("returned set should contain lemon path", result.getCurrentPathSet().contains(lemonPath)); |
| assertNotNull("there should be a lemon created", context.resourceResolver().getResource(lemonPath)); |
| } |
| |
| @Test |
| public void dryRun() throws Exception { |
| String lemonPath = "/content/fruits/lemon"; |
| PipeBuilder lemonBuilder = plumber.newPipe(context.resourceResolver()); |
| ExecutionResult result = lemonBuilder.mkdir(lemonPath).runWith("dryRun", true); |
| assertFalse("returned set should not contain lemon path with dryRun=true(boolean)", result.getCurrentPathSet().contains(lemonPath)); |
| ExecutionResult textResult = lemonBuilder.mkdir(lemonPath).runWith("dryRun", "true"); |
| assertFalse("returned set should not contain lemon path with dryRun=true(text)", textResult.getCurrentPathSet().contains(lemonPath)); |
| } |
| |
| @Test |
| public void confBuild() throws Exception { |
| PipeBuilder writeBuilder = plumber.newPipe(context.resourceResolver()); |
| writeBuilder.echo(PATH_APPLE).write("tested", true, "working", true).run(); |
| ValueMap properties = context.resourceResolver().getResource(PATH_APPLE).adaptTo(ValueMap.class); |
| assertTrue("properties should have been written", properties.get("tested", false) && properties.get("working", false)); |
| } |
| |
| @Test |
| public void confContainerProperties() throws Exception { |
| PipeBuilder containerBuilder = plumber.newPipe(context.resourceResolver()); |
| containerBuilder.with("test",true); |
| String specialPath = "/content/testedContainer"; |
| containerBuilder.echo(PATH_APPLE).write("tested", true, "working", true).build(specialPath); |
| ValueMap properties = context.resourceResolver().getResource(specialPath).adaptTo(ValueMap.class); |
| assertTrue("property should have been written", properties.get("test", false)); |
| } |
| |
| @Test |
| public void bindings() throws Exception { |
| PipeBuilder defaultNames = plumber.newPipe(context.resourceResolver()); |
| ExecutionResult result = defaultNames |
| .echo(PATH_FRUITS) |
| .children("nt:unstructured") |
| .grep("slingPipesFilter_test","${two.worm}") |
| .children("nt:unstructured#isnota") |
| .children("nt:unstructured").name("thing") |
| .write("jcr:path", "${path.thing}") |
| .run(); |
| assertEquals("There should be 3 resources", 3, result.size()); |
| String pea = "/content/fruits/apple/isnota/pea"; |
| String carrot = "/content/fruits/apple/isnota/carrot"; |
| Collection<String> paths = result.getCurrentPathSet(); |
| assertTrue("the paths should contain " + pea, paths.contains(pea)); |
| assertTrue("the paths should contain " + carrot, paths.contains(carrot)); |
| for (String path : paths){ |
| String writtenPath = context.resourceResolver().getResource(path).adaptTo(ValueMap.class).get("jcr:path", String.class); |
| assertEquals("written path should be the same as actual path", path, writtenPath); |
| } |
| } |
| |
| @Test |
| public void additionalBindings() throws Exception { |
| Map bindings = new HashMap<>(); |
| bindings.put("testedPath", PATH_FRUITS); |
| ExecutionResult result = plumber.newPipe(context.resourceResolver()).echo("${testedPath}").run(bindings); |
| Collection<String> paths = result.getCurrentPathSet(); |
| assertTrue("paths should contain implemented testedPath after run(bindings) is executed", paths.contains(PATH_FRUITS)); |
| paths = plumber.newPipe(context.resourceResolver()) |
| .echo("${testedPath}").runWith("testedPath", PATH_FRUITS) |
| .getCurrentPathSet(); |
| assertTrue("paths should contain implemented testedPath after runWith is executed", paths.contains(PATH_FRUITS)); |
| } |
| |
| @Test |
| public void testOutputs() throws Exception { |
| ExecutionResult result = plumber.newPipe(context.resourceResolver()) |
| .echo(PATH_APPLE + "/isnota") |
| .children("").name("vegetable") |
| .outputs("name","Good ${vegetable['jcr:title']}") |
| .run(); |
| JsonObject object = JsonUtil.parseObject(result.toString()); |
| Collection<String> names = object.getJsonArray("items").getValuesAs(JsonObject.class) |
| .stream() |
| .map(o -> o.getString("name")) |
| .collect(Collectors.toList()); |
| Collection<String> expected = Arrays.asList(new String[] {"Good Pea", "Good Carrot", "Good Plum"}); |
| assertTrue("all transformed items should be here", CollectionUtils.intersection(names, expected).size() == 3); |
| } |
| } |