/*
* 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 junit.framework.TestCase;
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;
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.toURI().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;
}
}
}