Skip to content

Commit 3c53443

Browse files
chanseokohchanseokoh
authored
Simplify library code (#1587)
* Simplify library code * Empty commit to preserve build logs * Refactor and add tests
1 parent 8e343af commit 3c53443

14 files changed

Lines changed: 212 additions & 146 deletions

File tree

‎plugins/com.google.cloud.tools.eclipse.appengine.libraries.test/src/com/google/cloud/tools/eclipse/appengine/libraries/BuildPathTest.java‎

Lines changed: 14 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,9 @@
1616

1717
package com.google.cloud.tools.eclipse.appengine.libraries;
1818

19+
import com.google.cloud.tools.eclipse.appengine.libraries.model.Library;
1920
import java.util.ArrayList;
2021
import java.util.List;
21-
2222
import org.eclipse.core.resources.IProject;
2323
import org.eclipse.core.runtime.CoreException;
2424
import org.eclipse.core.runtime.IProgressMonitor;
@@ -29,10 +29,8 @@
2929
import org.junit.Test;
3030
import org.mockito.Mockito;
3131

32-
import com.google.cloud.tools.eclipse.appengine.libraries.model.Library;
33-
3432
public class BuildPathTest {
35-
33+
3634
private final List<Library> libraries = new ArrayList<>();
3735
private final IJavaProject project = Mockito.mock(IJavaProject.class);
3836

@@ -46,54 +44,54 @@ public void testAddLibraries_emptyList() throws CoreException {
4644
public void testAddLibraries() throws CoreException {
4745
IClasspathEntry[] rawClasspath = new IClasspathEntry[0];
4846
Mockito.when(project.getRawClasspath()).thenReturn(rawClasspath);
49-
47+
5048
Library library = new Library("libraryId");
5149
libraries.add(library);
5250
IClasspathEntry[] result =
5351
BuildPath.addLibraries(project, libraries, new NullProgressMonitor());
5452
Assert.assertEquals(1, result.length);
55-
53+
5654
Mockito.verify(project)
5755
.setRawClasspath(Mockito.any(IClasspathEntry[].class), Mockito.any(IProgressMonitor.class));
5856
}
59-
57+
6058
@Test
6159
public void testListAdditionalLibraries() throws CoreException {
6260
IClasspathEntry[] rawClasspath = new IClasspathEntry[0];
6361
Mockito.when(project.getRawClasspath()).thenReturn(rawClasspath);
64-
62+
6563
Library library = new Library("libraryId");
6664
libraries.add(library);
6765
IClasspathEntry[] result =
6866
BuildPath.listAdditionalLibraries(project, libraries, new NullProgressMonitor());
6967
Assert.assertEquals(1, result.length);
70-
68+
7169
Mockito.verify(project, Mockito.never())
7270
.setRawClasspath(Mockito.any(IClasspathEntry[].class), Mockito.any(IProgressMonitor.class));
7371
}
74-
72+
7573
@Test
7674
public void testAddLibraries_noDuplicates() throws CoreException {
7775
Library library = new Library("libraryId");
78-
IClasspathEntry entry = BuildPath.makeClasspathEntry(library);
76+
IClasspathEntry entry = BuildPath.makeClasspathEntry(library);
7977
IClasspathEntry[] rawClasspath = {entry};
8078
Mockito.when(project.getRawClasspath()).thenReturn(rawClasspath);
81-
79+
8280
libraries.add(library);
8381
IClasspathEntry[] result =
8482
BuildPath.addLibraries(project, libraries, new NullProgressMonitor());
8583
Assert.assertEquals(0, result.length);
8684
}
87-
85+
8886
@Test
8987
public void testAddLibraries_withDuplicates() throws CoreException {
9088
Library library1 = new Library("library1");
9189
Library library2 = new Library("library2");
9290
IClasspathEntry entry = BuildPath.makeClasspathEntry(library1);
93-
91+
9492
IClasspathEntry[] rawClasspath = {entry};
9593
Mockito.when(project.getRawClasspath()).thenReturn(rawClasspath);
96-
94+
9795
libraries.add(library1);
9896
libraries.add(library2);
9997
IClasspathEntry[] result =
@@ -102,5 +100,5 @@ public void testAddLibraries_withDuplicates() throws CoreException {
102100
Assert.assertTrue(result[0].getPath().toString()
103101
.endsWith("com.google.cloud.tools.eclipse.appengine.libraries/library2"));
104102
}
105-
103+
106104
}

‎plugins/com.google.cloud.tools.eclipse.appengine.libraries.test/src/com/google/cloud/tools/eclipse/appengine/libraries/LibraryClasspathContainerInitializerTest.java‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -128,18 +128,18 @@ public void testInitialize_deserializingContainerThrowsError() throws IOExceptio
128128
public void testInitialize_ifArtifactJarPathIsInvalidContainerResolvedFromScratch() throws CoreException,
129129
IOException {
130130
assertFalse(new File(NON_EXISTENT_FILE).exists());
131-
131+
132132
IClasspathEntry entry = mock(IClasspathEntry.class);
133133
when(entry.getPath()).thenReturn(new Path(NON_EXISTENT_FILE));
134134
IClasspathEntry[] entries = new IClasspathEntry[]{ entry };
135135
LibraryClasspathContainer container = mock(LibraryClasspathContainer.class);
136136
when(container.getClasspathEntries()).thenReturn(entries);
137137
when(serializer.loadContainer(any(IJavaProject.class), any(IPath.class))).thenReturn(container);
138-
138+
139139
LibraryClasspathContainerInitializer containerInitializer =
140140
new LibraryClasspathContainerInitializer(TEST_CONTAINER_PATH, serializer, resolverService);
141141
containerInitializer.initialize(new Path(TEST_LIBRARY_PATH), testProject.getJavaProject());
142-
142+
143143
verifyContainerResolvedFromScratch();
144144
}
145145

@@ -148,32 +148,32 @@ public void testInitialize_ifSourceArtifactJarPathInvalidContainerResolvedFromSc
148148
IOException {
149149
File artifactFile = temporaryFolder.newFile();
150150
assertFalse(new File(NON_EXISTENT_FILE).exists());
151-
151+
152152
IClasspathEntry entry = mock(IClasspathEntry.class);
153153
when(entry.getPath()).thenReturn(new Path(artifactFile.getAbsolutePath()));
154154
when(entry.getSourceAttachmentPath()).thenReturn(new Path(NON_EXISTENT_FILE));
155155
IClasspathEntry[] entries = new IClasspathEntry[]{ entry };
156156
LibraryClasspathContainer container = mock(LibraryClasspathContainer.class);
157157
when(container.getClasspathEntries()).thenReturn(entries);
158158
when(serializer.loadContainer(any(IJavaProject.class), any(IPath.class))).thenReturn(container);
159-
159+
160160
LibraryClasspathContainerInitializer containerInitializer =
161161
new LibraryClasspathContainerInitializer(TEST_CONTAINER_PATH, serializer, resolverService);
162162
containerInitializer.initialize(new Path(TEST_LIBRARY_PATH), testProject.getJavaProject());
163-
163+
164164
verifyContainerResolvedFromScratch();
165165
}
166166

167167
@Test
168168
public void testInitialize_ifSourcePathIsNullContainerIsNotResolvedAgain() throws CoreException, IOException {
169169
File artifactFile = temporaryFolder.newFile();
170-
170+
171171
IClasspathEntry entry = JavaCore.newLibraryEntry(new Path(artifactFile.getAbsolutePath()), null, null);
172172
IClasspathEntry[] entries = new IClasspathEntry[]{ entry };
173173
LibraryClasspathContainer container = mock(LibraryClasspathContainer.class);
174174
when(container.getClasspathEntries()).thenReturn(entries);
175175
when(serializer.loadContainer(any(IJavaProject.class), any(IPath.class))).thenReturn(container);
176-
176+
177177
LibraryClasspathContainerInitializer containerInitializer =
178178
new LibraryClasspathContainerInitializer(TEST_CONTAINER_PATH, serializer, resolverService);
179179
containerInitializer.initialize(new Path(TEST_LIBRARY_PATH), testProject.getJavaProject());
@@ -188,15 +188,15 @@ public void testInitialize_ifSourcePathIsNullContainerIsNotResolvedAgain() throw
188188
public void testInitialize_ifSourcePathIsValidContainerIsNotResolvedAgain() throws CoreException, IOException {
189189
File artifactFile = temporaryFolder.newFile();
190190
File sourceArtifactFile = temporaryFolder.newFile();
191-
191+
192192
IClasspathEntry entry = JavaCore.newLibraryEntry(new Path(artifactFile.getAbsolutePath()),
193193
new Path(sourceArtifactFile.getAbsolutePath()),
194194
null);
195195
IClasspathEntry[] entries = new IClasspathEntry[]{ entry };
196196
LibraryClasspathContainer container = mock(LibraryClasspathContainer.class);
197197
when(container.getClasspathEntries()).thenReturn(entries);
198198
when(serializer.loadContainer(any(IJavaProject.class), any(IPath.class))).thenReturn(container);
199-
199+
200200
LibraryClasspathContainerInitializer containerInitializer =
201201
new LibraryClasspathContainerInitializer(TEST_CONTAINER_PATH, serializer, resolverService);
202202
containerInitializer.initialize(new Path(TEST_LIBRARY_PATH), testProject.getJavaProject());

‎plugins/com.google.cloud.tools.eclipse.appengine.libraries.test/src/com/google/cloud/tools/eclipse/appengine/libraries/LibraryClasspathContainerTest.java‎

Lines changed: 9 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -22,56 +22,46 @@
2222
import static org.junit.Assert.assertThat;
2323
import static org.mockito.Mockito.mock;
2424

25+
import java.util.Arrays;
26+
import java.util.List;
2527
import org.eclipse.core.runtime.IPath;
2628
import org.eclipse.core.runtime.Path;
2729
import org.eclipse.jdt.core.IClasspathContainer;
2830
import org.eclipse.jdt.core.IClasspathEntry;
2931
import org.junit.Before;
3032
import org.junit.Test;
31-
import org.junit.runner.RunWith;
32-
import org.mockito.Mock;
33-
import org.mockito.runners.MockitoJUnitRunner;
3433

35-
@RunWith(MockitoJUnitRunner.class)
3634
public class LibraryClasspathContainerTest {
3735

38-
@Mock private IClasspathEntry mockClasspathEntry = mock(IClasspathEntry.class);
36+
private List<IClasspathEntry> mockClasspathEntry = Arrays.asList(mock(IClasspathEntry.class));
3937

4038
private LibraryClasspathContainer classpathContainer;
4139

4240
@Before
4341
public void setUp() {
4442
classpathContainer = new LibraryClasspathContainer(new Path("container/path"),
4543
"description",
46-
new IClasspathEntry[]{ mockClasspathEntry });
44+
mockClasspathEntry);
4745
}
4846

4947
@Test(expected = NullPointerException.class)
5048
public void testConstructor_nullPath() {
51-
new LibraryClasspathContainer(null,
52-
"description",
53-
new IClasspathEntry[]{ mockClasspathEntry });
49+
new LibraryClasspathContainer(null, "description", mockClasspathEntry);
5450
}
5551

5652
@Test(expected = NullPointerException.class)
5753
public void testConstructor_nullDescription() {
58-
new LibraryClasspathContainer(new Path("container/path"),
59-
null,
60-
new IClasspathEntry[]{ mockClasspathEntry });
54+
new LibraryClasspathContainer(new Path("container/path"), null, mockClasspathEntry);
6155
}
6256

6357
@Test(expected = IllegalArgumentException.class)
6458
public void testConstructor_emptyDescription() {
65-
new LibraryClasspathContainer(new Path("container/path"),
66-
"",
67-
new IClasspathEntry[]{ mockClasspathEntry });
59+
new LibraryClasspathContainer(new Path("container/path"), "", mockClasspathEntry);
6860
}
6961

7062
@Test(expected = NullPointerException.class)
7163
public void testConstructor_nullClasspathEntries() {
72-
new LibraryClasspathContainer(new Path("container/path"),
73-
"description",
74-
null);
64+
new LibraryClasspathContainer(new Path("container/path"), "description", null);
7565
}
7666

7767
@Test
@@ -94,6 +84,6 @@ public void testGetClasspathEntries() {
9484
IClasspathEntry[] classpathEntries = classpathContainer.getClasspathEntries();
9585
assertNotNull(classpathEntries);
9686
assertThat(classpathEntries.length, is(1));
97-
assertSame(mockClasspathEntry, classpathEntries[0]);
87+
assertSame(mockClasspathEntry.get(0), classpathEntries[0]);
9888
}
9989
}

‎plugins/com.google.cloud.tools.eclipse.appengine.libraries.test/src/com/google/cloud/tools/eclipse/appengine/libraries/SourceAttacherJobTest.java‎

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
/*
2+
* Copyright 2017 Google Inc.
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
17+
package com.google.cloud.tools.eclipse.appengine.libraries;
18+
19+
import static org.junit.Assert.assertNotNull;
20+
import static org.junit.Assert.assertNull;
21+
import static org.mockito.Matchers.any;
22+
import static org.mockito.Mockito.mock;
23+
import static org.mockito.Mockito.when;
24+
25+
import java.util.List;
26+
import java.util.concurrent.Callable;
27+
import org.eclipse.core.resources.IProject;
28+
import org.eclipse.core.runtime.IPath;
29+
import org.eclipse.jdt.core.IClasspathContainer;
30+
import org.eclipse.jdt.core.IClasspathEntry;
31+
import org.eclipse.jdt.core.IJavaProject;
32+
import org.junit.Before;
33+
import org.junit.Test;
34+
import org.junit.runner.RunWith;
35+
import org.mockito.runners.MockitoJUnitRunner;
36+
37+
@RunWith(MockitoJUnitRunner.class)
38+
public class SourceAttacherJobTest {
39+
40+
private SourceAttacherJob attacherJob;
41+
42+
@Before
43+
public void setUp() {
44+
IPath path = mock(IPath.class);
45+
IJavaProject javaProject = mock(IJavaProject.class);
46+
when(javaProject.getProject()).thenReturn(mock(IProject.class));
47+
attacherJob = new SourceAttacherJob(javaProject, path, path, mock(Callable.class));
48+
}
49+
50+
@Test
51+
public void testAttachSource_normalExecutionOnLibraryClasspathContainer() throws Exception {
52+
LibraryClasspathContainer validContainer = mock(LibraryClasspathContainer.class);
53+
when(validContainer.getClasspathEntries()).thenReturn(new IClasspathEntry[0]);
54+
when(validContainer.copyWithNewEntries(any(List.class))).thenReturn(validContainer);
55+
56+
LibraryClasspathContainer newContainer = attacherJob.attachSource(validContainer);
57+
assertNotNull(newContainer);
58+
}
59+
60+
@Test
61+
public void testAttachSource_shortCircuitOnGenericClasspathContainer() throws Exception {
62+
IClasspathContainer invalidContainer = mock(IClasspathContainer.class);
63+
64+
LibraryClasspathContainer newContainer = attacherJob.attachSource(invalidContainer);
65+
assertNull(newContainer);
66+
}
67+
}

‎plugins/com.google.cloud.tools.eclipse.appengine.libraries.test/src/com/google/cloud/tools/eclipse/appengine/libraries/persistence/LibraryClasspathContainerSerializerTest.java‎

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,8 @@
2828
import java.nio.charset.StandardCharsets;
2929
import java.nio.file.Files;
3030
import java.nio.file.StandardOpenOption;
31+
import java.util.Arrays;
32+
import java.util.List;
3133
import org.eclipse.core.runtime.CoreException;
3234
import org.eclipse.core.runtime.IPath;
3335
import org.eclipse.core.runtime.Path;
@@ -89,12 +91,12 @@ public class LibraryClasspathContainerSerializerTest {
8991

9092
@Before
9193
public void setUp() throws Exception {
92-
IClasspathEntry[] classpathEntries =
93-
new IClasspathEntry[] {getClasspathEntry(IClasspathEntry.CPE_LIBRARY, "/test/path/to/jar",
94-
"/test/path/to/src", new IClasspathAttribute[] {getAttribute("attrName", "attrValue")},
95-
new IAccessRule[] {getAccessRule("/com/example/accessible", true /* accessible */),
96-
getAccessRule("/com/example/nonaccessible", false /* accessible */)},
97-
true)};
94+
List<IClasspathEntry> classpathEntries = Arrays.asList(
95+
newClasspathEntry(IClasspathEntry.CPE_LIBRARY, "/test/path/to/jar",
96+
"/test/path/to/src", new IClasspathAttribute[] {newAttribute("attrName", "attrValue")},
97+
new IAccessRule[] {newAccessRule("/com/example/accessible", true /* accessible */),
98+
newAccessRule("/com/example/nonaccessible", false /* accessible */)},
99+
true));
98100
when(binaryBaseLocationProvider.getBaseLocation()).thenReturn(new Path("/test"));
99101
when(sourceBaseLocationProvider.getBaseLocation()).thenReturn(new Path("/test"));
100102
container = new LibraryClasspathContainer(new Path(CONTAINER_PATH), CONTAINER_DESCRIPTION,
@@ -185,7 +187,7 @@ private void compare(LibraryClasspathContainer container,
185187
}
186188
}
187189

188-
private IClasspathEntry getClasspathEntry(final int entryKind, final String path,
190+
private static IClasspathEntry newClasspathEntry(final int entryKind, final String path,
189191
final String sourceAttachmentPath, final IClasspathAttribute[] attributes,
190192
final IAccessRule[] accessRules, final boolean isExported) {
191193
return new IClasspathEntry() {
@@ -263,7 +265,7 @@ public boolean combineAccessRules() {
263265
};
264266
}
265267

266-
private IClasspathAttribute getAttribute(final String name, final String value) {
268+
private static IClasspathAttribute newAttribute(final String name, final String value) {
267269
return new IClasspathAttribute() {
268270

269271
@Override
@@ -278,7 +280,7 @@ public String getName() {
278280
};
279281
}
280282

281-
private IAccessRule getAccessRule(final String pattern, final boolean accessible) {
283+
private static IAccessRule newAccessRule(final String pattern, final boolean accessible) {
282284
return new IAccessRule() {
283285

284286
@Override

0 commit comments

Comments
 (0)