| /* |
| * 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.provisioning.model; |
| |
| import static org.apache.sling.provisioning.model.ModelConstants.DEFAULT_RUN_MODE; |
| import static org.apache.sling.provisioning.model.ModelConstants.DEFAULT_START_LEVEL; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.io.InputStreamReader; |
| import java.io.Reader; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.sling.provisioning.model.io.ModelReader; |
| |
| /** Test utilities */ |
| public class U { |
| |
| public static final String[] TEST_MODEL_FILENAMES = |
| new String[] {"boot.txt", "example.txt", "main.txt", "oak.txt"}; |
| |
| public static void assertArtifact(ArtifactGroup g, String mvnUrl) { |
| final Artifact a = Artifact.fromMvnUrl(mvnUrl); |
| if(!g.items.contains(a)) { |
| fail("Expecting ArtifactGroup to contain '" + mvnUrl + "': " + g); |
| } |
| } |
| |
| /** Read our test model by merging our TEST_MODEL_FILENAMES */ |
| public static Model readCompleteTestModel() throws Exception { |
| return readCompleteTestModel(TEST_MODEL_FILENAMES); |
| } |
| |
| /** Read the complete model from that names */ |
| public static Model readCompleteTestModel(final String[] names) throws Exception { |
| Model result = null; |
| |
| for(final String name : names) { |
| final Reader reader = new InputStreamReader(U.class.getResourceAsStream("/" + name), "UTF-8"); |
| try { |
| final Model current = ModelReader.read(reader, name); |
| final Map<Traceable, String> errors = ModelUtility.validate(current); |
| if (errors != null ) { |
| throw new Exception("Invalid model at " + name + " : " + errors); |
| } |
| if ( result == null ) { |
| result = current; |
| } else { |
| ModelUtility.merge(result, current); |
| } |
| } finally { |
| reader.close(); |
| } |
| } |
| |
| final Map<Traceable, String> errors = ModelUtility.validate(result); |
| if (errors != null ) { |
| throw new Exception("Invalid merged model : " + errors); |
| } |
| return result; |
| } |
| |
| public static ArtifactGroup getGroup(Model m, String feature, String runMode, int startLevel) { |
| final Feature f = m.getFeature(feature); |
| assertNotNull(f); |
| final RunMode rm = f.getRunMode(runMode); |
| assertNotNull(rm); |
| final ArtifactGroup g = rm.getArtifactGroup(startLevel); |
| assertNotNull(g); |
| return g; |
| } |
| |
| /** Verify that m matches what we expect after |
| * reading and merging our test files. |
| */ |
| public static void verifyTestModel(Model m, boolean variablesAlreadyResolved) { |
| final String [] f = { ":launchpad","example","main","oak" }; |
| for(String name : f) { |
| assertNotNull("Expecting feature to be present:" + name, m.getFeature(name)); |
| } |
| |
| { |
| final ArtifactGroup g = getGroup(m, "example", DEFAULT_RUN_MODE, DEFAULT_START_LEVEL); |
| U.assertArtifact(g, "mvn:commons-collections/commons-collections/3.2.1/jar"); |
| U.assertArtifact(g, "mvn:org.example/jar-is-default/1.2/jar"); |
| } |
| |
| { |
| final ArtifactGroup g = getGroup(m, "example", "jackrabbit", 15); |
| if(variablesAlreadyResolved) { |
| U.assertArtifact(g, "mvn:org.apache.sling/org.apache.sling.jcr.jackrabbit.server/2.1.3-SNAPSHOT/jar"); |
| } else { |
| U.assertArtifact(g, "mvn:org.apache.sling/org.apache.sling.jcr.jackrabbit.server/${jackrabbit.version}/jar"); |
| } |
| } |
| |
| { |
| final ArtifactGroup g = getGroup(m, ":boot", DEFAULT_RUN_MODE, DEFAULT_START_LEVEL); |
| if(variablesAlreadyResolved) { |
| U.assertArtifact(g, "mvn:org.apache.sling/org.apache.sling.fragment.ws/1.42-from-boot/jar"); |
| } else { |
| U.assertArtifact(g, "mvn:org.apache.sling/org.apache.sling.fragment.ws/${ws.version}/jar"); |
| } |
| } |
| final Feature exampleFeature = m.getFeature("example"); |
| final RunMode defaultExampleRM = exampleFeature.getRunMode(); |
| final List<Configuration> configs = assertConfigurationsInRunMode(defaultExampleRM, 3); |
| final Configuration cfg = assertConfiguration(configs, "org.apache.sling.another.config"); |
| } |
| |
| public static Configuration assertConfiguration(final List<Configuration> configs, final String pid) { |
| for(final Configuration c : configs) { |
| if ( c.getPid().equals(pid) && c.getFactoryPid() == null ) { |
| return c; |
| } |
| } |
| fail("Configuration with PID " + pid + " not found in " + configs); |
| return null; |
| } |
| |
| public static void assertArtifact(final Artifact artifact, |
| final String groupId, final String artifactId, final String version, final String type, final String classifier) { |
| assertNotNull(artifact); |
| assertEquals(groupId, artifact.getGroupId()); |
| assertEquals(artifactId, artifact.getArtifactId()); |
| assertEquals(version, artifact.getVersion()); |
| assertEquals(type, artifact.getType()); |
| assertEquals(classifier, artifact.getClassifier()); |
| } |
| |
| public static List<Artifact> assertArtifactsInGroup(final ArtifactGroup group, final int size) { |
| final List<Artifact> result = new ArrayList<Artifact>(); |
| if ( size == 0 ) { |
| assertTrue("Group should be empty", group.isEmpty()); |
| } else { |
| assertFalse("Group should not be empty", group.isEmpty()); |
| } |
| for(final Artifact a : group) { |
| result.add(a); |
| } |
| assertEquals("Unexpected size of group: ", size, result.size()); |
| return result; |
| } |
| |
| public static List<Configuration> assertConfigurationsInRunMode(final RunMode runmode, final int size) { |
| final List<Configuration> result = new ArrayList<Configuration>(); |
| if ( size == 0 ) { |
| assertTrue("Configurations should be empty", runmode.getConfigurations().isEmpty()); |
| } else { |
| assertFalse("Configurations should not be empty", runmode.getConfigurations().isEmpty()); |
| } |
| for(final Configuration a : runmode.getConfigurations()) { |
| result.add(a); |
| } |
| assertEquals("Unexpected size of configurations: ", size, result.size()); |
| return result; |
| } |
| } |