@Test
public void shouldInstanciateDependency() {
MainActivityComponent component = DaggerMainActivityComponent.create();
Dependency dependency = component.dependency();
assertThat(dependency).isNotNull();
assertThat(dependency.which()).isEqualTo("anonymous");
}
public WikiName next() {
Dependency result = _next;
skip();
return result.getWikiName();
}
private Map<String, List<Dependency>> specifyDeps(List<CloudApplication> apps) {
Map<String, List<Dependency>> deps = new HashMap<String, List<Dependency>>();
Scanner reader = new Scanner(System.in);
while (true) {
// System.out.println("Specify Dependency Using format A->B (A depends on B)?(Y/N)");
// FIXME: more robust input handling
String line = reader.nextLine();
if (line.isEmpty()) {
break;
}
String[] ab = line.split("->");
Dependency dep = new Dependency();
CloudApplication sourceApp = apps.get(Integer.parseInt(ab[0]) - 1);
dep.setSource(sourceApp);
dep.setTarget(apps.get(Integer.parseInt(ab[1]) - 1));
List<Dependency> list = deps.get(sourceApp.getName());
if (list == null) {
list = new ArrayList<Dependency>();
deps.put(sourceApp.getName(), list);
}
list.add(dep);
System.out.println(
"Generate the depends-on relationship in application model according to the manually-defined dependency");
}
return deps;
}
@Override
public int compareTo(Dependency o) {
int compare = getName().compareTo(o.getName());
if (compare == 0) {
compare = getShuffleType().compareTo(o.getShuffleType());
}
return compare;
}
public Collection<String> getBuildDependencyPatterns() {
Collection<String> dependencies = new ArrayList<String>();
for (Dependency buildDependency : buildDependencies) {
dependencies.add(buildDependency.getPattern());
}
return dependencies;
}
public boolean canExecute() {
for (Dependency dependency : dependencies) {
if (!dependency.canExecute()) {
return false;
}
}
return true;
}
/** Format deadlock displaying to a user. */
public static String prettyFormat(Collection<Dependency> deadlock) {
StringBuilder text = new StringBuilder();
LinkedHashSet<LocalThread> threads = new LinkedHashSet<LocalThread>();
Set<Object> seenDependers = new HashSet<>();
Object lastDependsOn = text;
Object lastDepender = text;
for (Dependency dep : deadlock) {
Object depender = dep.getDepender();
Object dependsOn = dep.getDependsOn();
String dependerString;
if (lastDependsOn.equals(depender)) {
dependerString = "which";
} else if (lastDepender.equals(depender)) {
dependerString = "and";
} else {
dependerString = String.valueOf(depender);
}
lastDepender = depender;
lastDependsOn = dependsOn;
String also = seenDependers.contains(depender) ? " also" : "";
seenDependers.add(depender);
if (depender instanceof LocalThread) {
text.append(dependerString)
.append(" is")
.append(also)
.append(" waiting on ")
.append(dependsOn)
.append("\n");
threads.add((LocalThread) depender);
} else if (dependsOn instanceof LocalThread) {
text.append(dependerString).append(" is held by thread ").append(dependsOn).append("\n");
threads.add((LocalThread) dependsOn);
} else {
text.append(dependerString)
.append(" is")
.append(also)
.append(" waiting for ")
.append(dependsOn)
.append("\n");
}
text.append("\n");
}
text.append("\nStack traces for involved threads\n");
for (LocalThread threadInfo : threads) {
text.append(threadInfo.getLocatility())
.append(":")
.append(threadInfo.getThreadStack())
.append("\n\n");
}
return text.toString();
}
public List<Dependency> getUnsatisfiedDependencies(String plugin) {
List<Dependency> deps = new ArrayList<Dependency>();
for (Dependency dep : getDependencies(plugin)) {
if (!dep.isInstalled() || dep.isUpgrade()) {
deps.add(dep);
}
}
return deps;
}
@Test
public void importMockInReusableVerificationBlock() {
new ReusableExpectations() {};
dependency.notifyBeforeSave();
dependency.save();
new ReusableVerifications() {};
}
private <T> void addDependency(ServiceBuilder<?> builder, Dependency<T> dependency) {
final ServiceName name = dependency.getName();
final Injector<T> injector = dependency.getInjector();
if (injector != null) {
builder.addDependency(name, dependency.getType(), injector);
} else {
builder.addDependency(name);
}
}
@Override
protected List<Dependency> constructDependencies() {
final List<Dependency> dependencies = constructDynamicChildrenDependencies();
for (Dependency dependency : dependencies) {
if (dependency.getOther() == getTarget()) {
dependency.setMandatory(true);
}
}
return dependencies;
}
@Test
public void testConstructWithCustomTypeAndScope() {
// Set up
final Dependency dependency =
new Dependency(
DEPENDENCY_GROUP_ID, DEPENDENCY_ARTIFACT_ID, DEPENDENCY_VERSION, ZIP, PROVIDED);
// Invoke and check
assertEquals(ZIP, dependency.getType());
assertEquals(PROVIDED, dependency.getScope());
}
@Test
public void shouldInstanciateAnotherDependency() {
Dependency dependency =
DaggerMainActivityComponent.builder()
.mainActivityModule(new TestModule())
.build()
.controller()
.getDependency();
assertThat(dependency).isNotNull();
assertThat(dependency.which()).isEqualTo("impl");
}
@Test(expected = UnexpectedInvocation.class)
public void verifyAllWithUnverifiedReplayOnSameInstance(final Dependency mock2) {
mock.editABunchMoreStuff();
mock2.editABunchMoreStuff();
new FullVerifications(mock2) {
{
mock.editABunchMoreStuff();
}
};
}
private void genAppDepRelation(AppModel model, Map<String, List<Dependency>> deps) {
for (List<Dependency> list : deps.values()) {
for (Dependency dep : list) {
Relationship r = new Relationship();
r.setSourceNode(dep.getSource().getName());
r.setTargetNode(dep.getTarget().getName());
r.setType(RelationshipType.dependsOn);
model.addRelationship(r);
}
}
}
@Test
public void withTransitionAndAspects_AllowsEmptyAspectSet() throws Exception {
update();
Dependency dep =
Dependency.withTransitionAndAspects(
Label.parseAbsolute("//a"),
ConfigurationTransition.HOST,
ImmutableSet.<AspectDescriptor>of());
// Here we're also checking that this doesn't throw an exception. No boom? OK. Good.
assertThat(dep.getAspects()).isEmpty();
}
public void addDC(Dependency d) {
if (!(d.getConclusion() instanceof NullFormula)) {
throw new ParserException("DC must have no conclusion");
}
IDatabase source = task.getSource();
List<String> sourceTables = source.getTableNames();
IDatabase target = task.getTarget();
List<String> targetTables = target.getTableNames();
checkAtomsForDCs(sourceTables, targetTables, d.getPremise());
this.dcs.add(d);
}
public Dependency getDependency(String artifactId) {
if (this.dependencies == null || this.dependencies.size() == 0) {
return null;
}
for (Dependency depend : this.dependencies) {
if (artifactId.equals(depend.getArtifactId())) {
return depend;
}
}
return null;
}
@Test
public void withConfiguredAspects_AllowsEmptyAspectMap() throws Exception {
update();
Dependency dep =
Dependency.withConfiguredAspects(
Label.parseAbsolute("//a"),
getTargetConfiguration(),
ImmutableMap.<AspectDescriptor, BuildConfiguration>of());
// Here we're also checking that this doesn't throw an exception. No boom? OK. Good.
assertThat(dep.getAspects()).isEmpty();
assertThat(dep.getAspectConfigurations()).isEmpty();
}
public List<String> buildProject(List<ProjectType> projects, List<Dependency> dependencies) {
List<String> incompatibilities = new ArrayList<String>();
for (Dependency dep : dependencies) {
for (ProjectType type : projects) {
dep.getDependencies(type);
incompatibilities.addAll(dep.getIncompatibilities(type));
}
}
this.modules = projects;
this.dependencies = dependencies;
return incompatibilities;
}
@Test
public void testNullDependencyDoesNotHaveSameCoordinates() {
// Set up
final Dependency dependency =
new Dependency(DEPENDENCY_GROUP_ID, DEPENDENCY_ARTIFACT_ID, DEPENDENCY_VERSION);
// Invoke
final boolean same = dependency.hasSameCoordinates(null);
// Check
assertFalse(same);
}
@Test
public void testGetElementForMinimalDependency() {
// Set up
final Dependency dependency =
new Dependency(DEPENDENCY_GROUP_ID, DEPENDENCY_ARTIFACT_ID, DEPENDENCY_VERSION);
// Invoke
final Element element = dependency.getElement(DOCUMENT_BUILDER.newDocument());
// Check
assertXmlEquals(EXPECTED_ELEMENT_FOR_MINIMAL_DEPENDENCY, element);
}
public boolean isDepended(String artifactId, String version) {
if (this.dependencies == null || this.dependencies.size() == 0) {
return false;
}
for (Dependency depend : this.dependencies) {
if (artifactId.equals(depend.getArtifactId())) {
if (version == null || version.equals(depend.getVersion())) {
return true;
}
}
}
return false;
}
@Test
public void shouldUseMockDependency() {
Dependency mock = Mockito.mock(Dependency.class);
when(mock.which()).thenReturn("mock");
Dependency dependency =
DaggerMainActivityComponent.builder()
.mainActivityModule(new TestModule(mock))
.build()
.controller()
.getDependency();
assertThat(dependency).isNotNull();
assertThat(dependency.which()).isEqualTo("mock");
}
@Test
public void testAddExclusion() {
// Set up
final Dependency dependency =
new Dependency(DEPENDENCY_GROUP_ID, DEPENDENCY_ARTIFACT_ID, DEPENDENCY_VERSION);
final int originalExclusionCount = dependency.getExclusions().size();
// Invoke
dependency.addExclusion(EXCLUSION_GROUP_ID, EXCLUSION_ARTIFACT_ID);
// Check
assertEquals(originalExclusionCount + 1, dependency.getExclusions().size());
}
@Test
public void withConfigurationAndAspects_BasicAccessors() throws Exception {
update();
AspectDescriptor simpleAspect = new AspectDescriptor(TestAspects.SIMPLE_ASPECT);
AspectDescriptor attributeAspect = new AspectDescriptor(TestAspects.ATTRIBUTE_ASPECT);
ImmutableSet<AspectDescriptor> twoAspects = ImmutableSet.of(simpleAspect, attributeAspect);
Dependency targetDep =
Dependency.withConfigurationAndAspects(
Label.parseAbsolute("//a"), getTargetConfiguration(), twoAspects);
assertThat(targetDep.getLabel()).isEqualTo(Label.parseAbsolute("//a"));
assertThat(targetDep.hasStaticConfiguration()).isTrue();
assertThat(targetDep.getConfiguration()).isEqualTo(getTargetConfiguration());
assertThat(targetDep.getAspects()).containsExactlyElementsIn(twoAspects);
assertThat(targetDep.getAspectConfigurations())
.containsExactlyEntriesIn(
ImmutableMap.of(
simpleAspect, getTargetConfiguration(),
attributeAspect, getTargetConfiguration()));
try {
targetDep.getTransition();
fail("withConfigurationAndAspects-created Dependencies should throw ISE on getTransition()");
} catch (IllegalStateException ex) {
// good. that's what I WANTED to happen.
}
}
@Test
public void withTransitionAndAspects_BasicAccessors() throws Exception {
AspectDescriptor simpleAspect = new AspectDescriptor(TestAspects.SIMPLE_ASPECT);
AspectDescriptor attributeAspect = new AspectDescriptor(TestAspects.ATTRIBUTE_ASPECT);
ImmutableSet<AspectDescriptor> twoAspects = ImmutableSet.of(simpleAspect, attributeAspect);
Dependency hostDep =
Dependency.withTransitionAndAspects(
Label.parseAbsolute("//a"), ConfigurationTransition.HOST, twoAspects);
assertThat(hostDep.getLabel()).isEqualTo(Label.parseAbsolute("//a"));
assertThat(hostDep.hasStaticConfiguration()).isFalse();
assertThat(hostDep.getAspects()).containsExactlyElementsIn(twoAspects);
assertThat(hostDep.getTransition()).isEqualTo(ConfigurationTransition.HOST);
try {
hostDep.getConfiguration();
fail("withTransitionAndAspects-created Dependencies should throw ISE on getConfiguration()");
} catch (IllegalStateException ex) {
// good. I knew you would do that.
}
try {
hostDep.getAspectConfigurations();
fail(
"withTransitionAndAspects-created Dependencies should throw ISE on "
+ "getAspectConfigurations()");
} catch (IllegalStateException ex) {
// good. you're so predictable.
}
}
@Test
public void withConfiguredAspects_BasicAccessors() throws Exception {
update();
AspectDescriptor simpleAspect = new AspectDescriptor(TestAspects.SIMPLE_ASPECT);
AspectDescriptor attributeAspect = new AspectDescriptor(TestAspects.ATTRIBUTE_ASPECT);
ImmutableMap<AspectDescriptor, BuildConfiguration> twoAspectMap =
ImmutableMap.of(
simpleAspect, getTargetConfiguration(), attributeAspect, getHostConfiguration());
Dependency targetDep =
Dependency.withConfiguredAspects(
Label.parseAbsolute("//a"), getTargetConfiguration(), twoAspectMap);
assertThat(targetDep.getLabel()).isEqualTo(Label.parseAbsolute("//a"));
assertThat(targetDep.hasStaticConfiguration()).isTrue();
assertThat(targetDep.getConfiguration()).isEqualTo(getTargetConfiguration());
assertThat(targetDep.getAspects())
.containsExactlyElementsIn(ImmutableSet.of(simpleAspect, attributeAspect));
assertThat(targetDep.getAspectConfigurations()).containsExactlyEntriesIn(twoAspectMap);
try {
targetDep.getTransition();
fail("withConfiguredAspects-created Dependencies should throw ISE on getTransition()");
} catch (IllegalStateException ex) {
// good. all according to keikaku. (TL note: keikaku means plan)
}
}
@Test
public void getDbModule() {
final Module module = DataModelFactory.createModule("root", "1.0.0-SNAPSHOT");
final Artifact artifact =
DataModelFactory.createArtifact(
"com.axway.root", "artifact1", "1.0.0-SNAPSHOT", "win", "component", "jar");
module.addArtifact(artifact);
final Artifact thirdparty =
DataModelFactory.createArtifact("org.apache", "all", "6.8.0-5426", "", "", "jar");
final Dependency dependency = DataModelFactory.createDependency(thirdparty, Scope.COMPILE);
module.addDependency(dependency);
final Module submodule = DataModelFactory.createModule("sub1", "1.0.0-SNAPSHOT");
final Artifact artifact2 =
DataModelFactory.createArtifact(
"com.axway.root.sub1", "artifactSub1", "1.0.0-SNAPSHOT", "", "", "jar");
submodule.addArtifact(artifact2);
final Artifact thirdparty2 =
DataModelFactory.createArtifact("org.lol", "all", "1.2.3-4", "", "", "jar");
final Dependency dependency2 = DataModelFactory.createDependency(thirdparty2, Scope.PROVIDED);
submodule.addDependency(dependency2);
module.addSubmodule(submodule);
final ModelMapper modelMapper = new ModelMapper(mock(RepositoryHandler.class));
final DbModule dbModule = modelMapper.getDbModule(module);
assertEquals(module.getName(), dbModule.getName());
assertEquals(module.getVersion(), dbModule.getVersion());
assertEquals(1, dbModule.getArtifacts().size());
assertEquals(artifact.getGavc(), dbModule.getArtifacts().get(0));
assertEquals(1, dbModule.getDependencies().size());
assertEquals(thirdparty.getGavc(), dbModule.getDependencies().get(0).getTarget());
assertEquals(
DbModule.generateID(module.getName(), module.getVersion()),
dbModule.getDependencies().get(0).getSource());
assertEquals(dependency.getScope(), dbModule.getDependencies().get(0).getScope());
assertEquals(1, dbModule.getSubmodules().size());
final DbModule dbSubmodule = dbModule.getSubmodules().get(0);
assertEquals(submodule.getName(), dbSubmodule.getName());
assertEquals(submodule.getVersion(), dbSubmodule.getVersion());
assertEquals(1, dbSubmodule.getArtifacts().size());
assertEquals(artifact2.getGavc(), dbSubmodule.getArtifacts().get(0));
assertEquals(1, dbSubmodule.getDependencies().size());
assertEquals(thirdparty2.getGavc(), dbSubmodule.getDependencies().get(0).getTarget());
assertEquals(
DbModule.generateID(submodule.getName(), submodule.getVersion()),
dbSubmodule.getDependencies().get(0).getSource());
assertEquals(dependency2.getScope(), dbSubmodule.getDependencies().get(0).getScope());
}
private static void updateDependencies(
final DependencyStructure other,
final UnifyingSubstitution substitution,
final Set<UnresolvedDependency> newUnresolvedDependencies,
final List<UnlabelledDependency> newResolvedDependencies) {
for (final UnresolvedDependency dep : other.unresolvedDependencies) {
final Dependency updated = substitution.applyTo(dep);
if (updated.isResolved()) {
newResolvedDependencies.add((UnlabelledDependency) updated);
} else {
newUnresolvedDependencies.add((UnresolvedDependency) updated);
}
}
}
