/*
* 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.ivy.core.publish;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import org.apache.ivy.Ivy;
import org.apache.ivy.core.IvyContext;
import org.apache.ivy.core.event.IvyEvent;
import org.apache.ivy.core.event.publish.EndArtifactPublishEvent;
import org.apache.ivy.core.event.publish.PublishEvent;
import org.apache.ivy.core.event.publish.StartArtifactPublishEvent;
import org.apache.ivy.core.module.descriptor.Artifact;
import org.apache.ivy.core.module.descriptor.MDArtifact;
import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorParser;
import org.apache.ivy.plugins.resolver.MockResolver;
import org.apache.ivy.plugins.trigger.AbstractTrigger;
import junit.framework.TestCase;
public class PublishEventsTest extends TestCase {
//maps ArtifactRevisionId to PublishTestCase instance.
private HashMap expectedPublications;
//expected values for the current artifact being published.
private PublishTestCase currentTestCase;
private boolean expectedOverwrite;
//number of times PrePublishTrigger has been invoked successfully
private int preTriggers;
//number of times PostPublishTrigger has been invoked successfully
private int postTriggers;
//number of times an artifact has been successfully published by the resolver
private int publications;
//dummy test data that is reused by all cases.
private File ivyFile;
private Artifact ivyArtifact;
private File dataFile;
private Artifact dataArtifact;
private ModuleDescriptor publishModule;
private Collection publishSources;
private PublishOptions publishOptions;
//if non-null, InstrumentedResolver will throw this exception during publish
private IOException publishError;
//the ivy instance under test
private Ivy ivy;
private PublishEngine publishEngine;
protected void setUp() throws Exception {
super.setUp();
//reset test case state.
resetCounters();
//this ivy settings should configure an InstrumentedResolver, PrePublishTrigger, and PostPublishTrigger
//(see inner classes below).
ivy = Ivy.newInstance();
ivy.configure(PublishEventsTest.class.getResource("ivysettings-publisheventstest.xml"));
ivy.pushContext();
publishEngine = ivy.getPublishEngine();
//setup dummy ivy and data files to test publishing. since we're testing the engine and not the resolver,
//we don't really care whether the file actually gets published. we just want to make sure
//that the engine calls the correct methods in the correct order, and fires required events.
ivyFile = new File("test/java/org/apache/ivy/core/publish/ivy-1.0-dev.xml");
assertTrue("path to ivy file not found in test environment", ivyFile.exists());
//the contents of the data file don't matter.
dataFile = File.createTempFile("ivydata", ".jar");
dataFile.deleteOnExit();
publishModule = XmlModuleDescriptorParser.getInstance().parseDescriptor(ivy.getSettings(), ivyFile.toURL(), false);
//always use the same source data file, no pattern substitution is required.
publishSources = Collections.singleton(dataFile.getAbsolutePath());
//always use the same ivy file, no pattern substitution is required.
publishOptions = new PublishOptions();
publishOptions.setSrcIvyPattern(ivyFile.getAbsolutePath());
//set up our expectations for the test. these variables will
//be checked by the resolver and triggers during publication.
dataArtifact = publishModule.getAllArtifacts()[0];
assertEquals("sanity check", "foo", dataArtifact.getName());
ivyArtifact = MDArtifact.newIvyArtifact(publishModule);
expectedPublications = new HashMap();
expectedPublications.put(dataArtifact.getId(), new PublishTestCase(dataArtifact, dataFile, true));
expectedPublications.put(ivyArtifact.getId(), new PublishTestCase(ivyArtifact, ivyFile, true));
assertEquals("hashCode sanity check: two artifacts expected during publish", 2, expectedPublications.size());
//push the TestCase instance onto the context stack, so that our
//triggers and resolver instances can interact with it it.
IvyContext.getContext().push(PublishEventsTest.class.getName(), this);
}
protected void tearDown() throws Exception {
super.tearDown();
//reset test state.
resetCounters();
//test case is finished, pop the test context off the stack.
IvyContext.getContext().pop(PublishEventsTest.class.getName());
//cleanup ivy resources
if (ivy != null) {
ivy.popContext();
ivy = null;
}
publishEngine = null;
if (dataFile != null)
dataFile.delete();
dataFile = null;
ivyFile = null;
}
protected void resetCounters() {
preTriggers = 0;
postTriggers = 0;
publications = 0;
expectedPublications = null;
expectedOverwrite = false;
publishError = null;
currentTestCase = null;
ivyArtifact = null;
dataArtifact = null;
}
/**
* Test a simple artifact publish, without errors or overwrite settings.
*/
public void testPublishNoOverwrite() throws IOException {
//no modifications to input required for this case -- call out to the resolver, and verify that
//all of our test counters have been incremented.
Collection missing = publishEngine.publish(publishModule.getModuleRevisionId(), publishSources, "default", publishOptions);
assertEquals("no missing artifacts", 0, missing.size());
//if all tests passed, all of our counter variables should have been updated.
assertEquals("pre-publish trigger fired and passed all tests", 2, preTriggers);
assertEquals("post-publish trigger fired and passed all tests", 2, postTriggers);
assertEquals("resolver received a publish() call, and passed all tests", 2, publications);
assertEquals("all expected artifacts have been published", 0, expectedPublications.size());
}
/**
* Test a simple artifact publish, with overwrite set to true.
*/
public void testPublishWithOverwrite() throws IOException {
//we expect the overwrite settings to be passed through the event listeners and into the publisher.
this.expectedOverwrite = true;
//set overwrite to true. InstrumentedResolver will verify that the correct argument value was provided.
publishOptions.setOverwrite(true);
Collection missing = publishEngine.publish(publishModule.getModuleRevisionId(), publishSources, "default", publishOptions);
assertEquals("no missing artifacts", 0, missing.size());
//if all tests passed, all of our counter variables should have been updated.
assertEquals("pre-publish trigger fired and passed all tests", 2, preTriggers);
assertEquals("post-publish trigger fired and passed all tests", 2, postTriggers);
assertEquals("resolver received a publish() call, and passed all tests", 2, publications);
assertEquals("all expected artifacts have been published", 0, expectedPublications.size());
}
/**
* Test an attempted publish with an invalid data file path.
*/
public void testPublishMissingFile() throws IOException {
//delete the datafile. the publish should fail
//and the ivy artifact should still publish successfully.
assertTrue("datafile has been destroyed", dataFile.delete());
PublishTestCase dataPublish = (PublishTestCase)expectedPublications.get(dataArtifact.getId());
dataPublish.expectedSuccess = false;
Collection missing = publishEngine.publish(publishModule.getModuleRevisionId(), publishSources, "default", publishOptions);
assertEquals("one missing artifact", 1, missing.size());
assertSameArtifact("missing artifact was returned", dataArtifact, (Artifact)missing.iterator().next());
//if all tests passed, all of our counter variables should have been updated.
assertEquals("pre-publish trigger fired and passed all tests", 1, preTriggers);
assertEquals("post-publish trigger fired and passed all tests", 1, postTriggers);
assertEquals("only the ivy file published successfully", 1, publications);
assertEquals("publish of all expected artifacts has been attempted", 1, expectedPublications.size());
}
/**
* Test an attempted publish in which the target resolver throws an IOException.
*/
public void testPublishWithException() {
//set an error to be thrown during publication of the data file.
this.publishError = new IOException("boom!");
//we don't care which artifact is attempted; either will fail with an IOException.
for (Iterator it = expectedPublications.values().iterator(); it.hasNext(); )
((PublishTestCase)it.next()).expectedSuccess = false;
try {
publishEngine.publish(publishModule.getModuleRevisionId(), publishSources, "default", publishOptions);
fail("if the resolver throws an exception, the engine should too");
} catch (IOException expected) {
assertSame("exception thrown by the resolver should be propagated by the engine",
this.publishError, expected);
}
//the publish engine gives up after the resolver throws an exception on the first artifact,
//so only one set of events should have been fired.
//note that the initial publish error shouldn't prevent the post-publish trigger from firing.
assertEquals("pre-publish trigger fired and passed all tests", 1, preTriggers);
assertEquals("post-publish trigger fired and passed all tests", 1, postTriggers);
assertEquals("resolver never published successfully", 0, publications);
assertEquals("publication aborted after first failure", 1, expectedPublications.size());
}
/**
* Assert that two Artifact instances refer to the same artifact and contain the same metadata.
*/
public static void assertSameArtifact(String message, Artifact expected, Artifact actual) {
assertEquals(message + ": name", expected.getName(), actual.getName());
assertEquals(message + ": id", expected.getId(), actual.getId());
assertEquals(message + ": moduleRevisionId", expected.getModuleRevisionId(), actual.getModuleRevisionId());
assertTrue(message + ": configurations", Arrays.equals(expected.getConfigurations(), actual.getConfigurations()));
assertEquals(message + ": type", expected.getType(), actual.getType());
assertEquals(message + ": ext", expected.getExt(), actual.getExt());
assertEquals(message + ": publicationDate", expected.getPublicationDate(), actual.getPublicationDate());
assertEquals(message + ": attributes", expected.getAttributes(), actual.getAttributes());
assertEquals(message + ": url", expected.getUrl(), actual.getUrl());
}
public static class PublishTestCase {
public Artifact expectedArtifact;
public File expectedData;
public boolean expectedSuccess;
public boolean preTriggerFired;
public boolean published;
public boolean postTriggerFired;
public PublishTestCase(Artifact artifact, File data, boolean success) {
this.expectedArtifact = artifact;
this.expectedData = data;
this.expectedSuccess = success;
}
}
/**
* Base class for pre- and post-publish-artifact triggers. When the trigger receives an event,
* the contents of the publish event are examined to make sure they match the variable settings
* on the calling {@link PublishEventsTest#currentTestCase} instance.
*/
public static class TestPublishTrigger extends AbstractTrigger {
public void progress(IvyEvent event) {
PublishEventsTest test = (PublishEventsTest)IvyContext.getContext().peek(PublishEventsTest.class.getName());
InstrumentedResolver resolver = (InstrumentedResolver)test.ivy.getSettings().getResolver("default");
assertNotNull("instrumented resolver configured", resolver);
assertNotNull("got a reference to the current unit test case", test);
//test the proper sequence of events by comparing the number of pre-events,
//post-events, and actual publications.
assertTrue("event is of correct base type",
event instanceof PublishEvent);
PublishEvent pubEvent = (PublishEvent)event;
Artifact expectedArtifact = test.currentTestCase.expectedArtifact;
File expectedData = test.currentTestCase.expectedData;
assertSameArtifact("event records correct artifact",
expectedArtifact, pubEvent.getArtifact());
try {
assertEquals("event records correct file",
expectedData.getCanonicalPath(), pubEvent.getData().getCanonicalPath());
assertEquals("event records correct overwrite setting", test.expectedOverwrite, pubEvent.isOverwrite());
assertSame("event presents correct resolver", resolver, pubEvent.getResolver());
String[] attributes = {
"organisation", "module", "revision", "artifact", "type", "ext", "resolver", "overwrite"
};
String[] values = {
"apache", "PublishEventsTest", "1.0-dev", expectedArtifact.getName(), expectedArtifact.getType(), expectedArtifact.getExt(), "default", String.valueOf(test.expectedOverwrite)
};
for (int i = 0; i < attributes.length; ++i)
assertEquals("event declares correct value for " + attributes[i],
values[i], event.getAttributes().get(attributes[i]));
//we test file separately, since it is hard to guaranteean exact path match, but we want
//to make sure that both paths point to the same canonical location on the filesystem
String filePath = event.getAttributes().get("file").toString();
assertEquals("event declares correct value for file",
expectedData.getCanonicalPath(), new File(filePath).getCanonicalPath());
} catch (IOException ioe) {
throw new RuntimeException(ioe);
}
}
}
/**
* Extends the tests done by {@link TestPublishTrigger} to check that pre-publish events are
* fired before DependencyResolver.publish() is called, and before post-publish events are fired.
*/
public static class PrePublishTrigger extends TestPublishTrigger {
public void progress(IvyEvent event) {
PublishEventsTest test = (PublishEventsTest)IvyContext.getContext().peek(PublishEventsTest.class.getName());
assertTrue("event is of correct concrete type",
event instanceof StartArtifactPublishEvent);
StartArtifactPublishEvent startEvent = (StartArtifactPublishEvent)event;
//verify that the artifact being publish was in the expected set. set the 'currentTestCase'
//pointer so that the resolver and post-publish trigger can check against it.
Artifact artifact = startEvent.getArtifact();
assertNotNull("event defines artifact", artifact);
PublishTestCase currentTestCase = (PublishTestCase)test.expectedPublications.remove(artifact.getId());
assertNotNull("artifact " + artifact.getId() + " was expected for publication", currentTestCase);
assertFalse("current publication has not been visited yet", currentTestCase.preTriggerFired);
assertFalse("current publication has not been visited yet", currentTestCase.published);
assertFalse("current publication has not been visited yet", currentTestCase.postTriggerFired);
test.currentTestCase = currentTestCase;
//superclass tests common attributes of publish events
super.progress(event);
//increment the call counter in the test
currentTestCase.preTriggerFired = true;
++test.preTriggers;
}
}
/**
* Extends the tests done by {@link TestPublishTrigger} to check that post-publish events are
* fired after DependencyResolver.publish() is called, and that the "status" attribute is
* set to the correct value.
*/
public static class PostPublishTrigger extends TestPublishTrigger {
public void progress(IvyEvent event) {
//superclass tests common attributes of publish events
super.progress(event);
PublishEventsTest test = (PublishEventsTest)IvyContext.getContext().peek(PublishEventsTest.class.getName());
//test the proper sequence of events by comparing the current count of pre-events,
//post-events, and actual publications.
assertTrue("event is of correct concrete type",
event instanceof EndArtifactPublishEvent);
assertTrue("pre-publish event has been triggered", test.preTriggers > 0);
//test sequence of events
assertTrue("pre-trigger event has already been fired for this artifact",
test.currentTestCase.preTriggerFired);
assertEquals("publication has been done if possible",
test.currentTestCase.expectedSuccess, test.currentTestCase.published);
assertFalse("post-publish event has not yet been fired for this artifact",
test.currentTestCase.postTriggerFired);
//test the "status" attribute of the post- event.
EndArtifactPublishEvent endEvent = (EndArtifactPublishEvent)event;
assertEquals("status bit is set correctly",
test.currentTestCase.expectedSuccess, endEvent.isSuccessful());
String expectedStatus = test.currentTestCase.expectedSuccess ? "successful" : "failed";
assertEquals("status attribute is set to correct value",
expectedStatus, endEvent.getAttributes().get("status"));
//increment the call counter in the wrapper test
test.currentTestCase.postTriggerFired = true;
++test.postTriggers;
}
}
/**
* When publish() is called, verifies that a pre-publish event has been fired, and also verifies that
* the method arguments have the correct value. Also simulates an IOException if the current
* test case demands it.
*/
public static class InstrumentedResolver extends MockResolver {
public void publish(Artifact artifact, File src, boolean overwrite) throws IOException {
//verify that the data from the current test case has been handed down to us
PublishEventsTest test = (PublishEventsTest)IvyContext.getContext().peek(PublishEventsTest.class.getName());
//test sequence of events.
assertNotNull(test.currentTestCase);
assertTrue("preTrigger has already fired", test.currentTestCase.preTriggerFired);
assertFalse("postTrigger has not yet fired", test.currentTestCase.postTriggerFired);
assertFalse("publish has not been called", test.currentTestCase.published);
//test event data
assertSameArtifact("publisher has received correct artifact",
test.currentTestCase.expectedArtifact, artifact);
assertEquals("publisher has received correct datafile",
test.currentTestCase.expectedData.getCanonicalPath(), src.getCanonicalPath());
assertEquals("publisher has received correct overwrite setting",
test.expectedOverwrite, overwrite);
assertTrue("publisher only invoked when source file exists", test.currentTestCase.expectedData.exists());
//simulate a publisher error if the current test case demands it.
if (test.publishError != null)
throw test.publishError;
//all assertions pass. increment the publication count
test.currentTestCase.published = true;
++test.publications;
}
}
}