From c5c432e2b37db7a6d13deee42bfa0d37fbc937da Mon Sep 17 00:00:00 2001 From: Dave Syer Date: Mon, 26 Jun 2017 08:12:55 +0100 Subject: [PATCH 1/3] Use undeprecated class --- .../config/server/environment/NativeEnvironmentRepository.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/NativeEnvironmentRepository.java b/spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/NativeEnvironmentRepository.java index c316b636..0987819f 100644 --- a/spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/NativeEnvironmentRepository.java +++ b/spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/NativeEnvironmentRepository.java @@ -27,7 +27,7 @@ import java.util.List; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.boot.Banner.Mode; -import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration; +import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration; import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.boot.context.config.ConfigFileApplicationListener; import org.springframework.boot.context.properties.ConfigurationProperties; From a64fe280f44ffc724736954cf956e3cffa93073a Mon Sep 17 00:00:00 2001 From: Dave Syer Date: Mon, 26 Jun 2017 08:49:22 +0100 Subject: [PATCH 2/3] Update build to latest --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index bbdbc97a..866033d2 100644 --- a/pom.xml +++ b/pom.xml @@ -11,7 +11,7 @@ org.springframework.cloud spring-cloud-build - 1.3.2.RELEASE + 1.3.3.RELEASE From e6a42aab95825f81942d5ca398d05a00c833a826 Mon Sep 17 00:00:00 2001 From: Dave Syer Date: Mon, 26 Jun 2017 09:20:31 +0100 Subject: [PATCH 3/3] Check for index.lock before attempting to use JGit A stale lock from a crashed JVM can prang the JGit client by preventing it from ever getting access to the working directory. This change attempts to clean the slate by removing the lock - because of the synchronization already present in the repository the only way this can go wrong is if multiple server instances are trying to share the working directory (which would be an eror for other reasons). --- .../JGitEnvironmentRepository.java | 152 +++++------ .../cloud/config/server/AdhocTestSuite.java | 25 ++ ...EnvironmentRepositoryIntegrationTests.java | 241 ++++++++---------- .../JGitEnvironmentRepositoryTests.java | 205 +++++++-------- 4 files changed, 309 insertions(+), 314 deletions(-) create mode 100644 spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/AdhocTestSuite.java diff --git a/spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepository.java b/spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepository.java index 1da9c00a..f94cd97e 100644 --- a/spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepository.java +++ b/spring-cloud-config-server/src/main/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepository.java @@ -75,23 +75,23 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository private static final String FILE_URI_PREFIX = "file:"; /** - * Timeout (in seconds) for obtaining HTTP or SSH connection (if applicable). Default - * 5 seconds. + * Timeout (in seconds) for obtaining HTTP or SSH connection (if + * applicable). Default 5 seconds. */ private int timeout = 5; private boolean initialized; /** - * Flag to indicate that the repository should be cloned on startup (not on demand). - * Generally leads to slower startup but faster first query. + * Flag to indicate that the repository should be cloned on startup (not on + * demand). Generally leads to slower startup but faster first query. */ private boolean cloneOnStart = false; private JGitEnvironmentRepository.JGitFactory gitFactory = new JGitEnvironmentRepository.JGitFactory(); private String defaultLabel = DEFAULT_LABEL; - + /** * The credentials provider to use to connect to the Git repository. */ @@ -103,8 +103,8 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository private TransportConfigCallback transportConfigCallback; /** - * Flag to indicate that the repository should force pull. If true discard any local - * changes and take from remote repository. + * Flag to indicate that the repository should force pull. If true discard + * any local changes and take from remote repository. */ private boolean forcePull; @@ -161,8 +161,7 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository } @Override - public synchronized Locations getLocations(String application, String profile, - String label) { + public synchronized Locations getLocations(String application, String profile, String label) { if (label == null) { label = this.defaultLabel; } @@ -173,8 +172,7 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository @Override public void afterPropertiesSet() throws Exception { - Assert.state(getUri() != null, - "You need to configure a uri for the git repository"); + Assert.state(getUri() != null, "You need to configure a uri for the git repository"); initialize(); if (this.cloneOnStart) { initClonedRepository(); @@ -191,41 +189,35 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository git = createGitClient(); if (shouldPull(git)) { fetch(git, label); - //checkout after fetch so we can get any new branches, tags, ect. + // checkout after fetch so we can get any new branches, tags, + // ect. checkout(git, label); - if(isBranch(git, label)) { - //merge results from fetch + if (isBranch(git, label)) { + // merge results from fetch merge(git, label); if (!isClean(git)) { - logger.warn("The local repository is dirty. Resetting it to origin/" - + label + "."); + logger.warn("The local repository is dirty. Resetting it to origin/" + label + "."); resetHard(git, label, "refs/remotes/origin/" + label); } } - } - else{ - //nothing to update so just checkout + } else { + // nothing to update so just checkout checkout(git, label); } - //always return what is currently HEAD as the version - return git.getRepository().getRef("HEAD").getObjectId().getName(); - } - catch (RefNotFoundException e) { + // always return what is currently HEAD as the version + return git.getRepository().findRef("HEAD").getObjectId().getName(); + } catch (RefNotFoundException e) { throw new NoSuchLabelException("No such label: " + label, e); - } - catch (GitAPIException e) { + } catch (GitAPIException e) { throw new IllegalStateException("Cannot clone or checkout repository", e); - } - catch (Exception e) { + } catch (Exception e) { throw new IllegalStateException("Cannot load environment", e); - } - finally { + } finally { try { if (git != null) { git.close(); } - } - catch (Exception e) { + } catch (Exception e) { this.logger.warn("Could not close git repository", e); } } @@ -233,6 +225,7 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository /** * Clones the remote repository and then opens a connection to it. + * * @throws GitAPIException * @throws IOException */ @@ -255,41 +248,35 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository CheckoutCommand checkout = git.checkout(); if (shouldTrack(git, label)) { trackBranch(git, checkout, label); - } - else { + } else { // works for tags and local branches checkout.setName(label); } return checkout.call(); } - protected boolean shouldPull(Git git) throws GitAPIException { boolean shouldPull; Status gitStatus = git.status().call(); boolean isWorkingTreeClean = gitStatus.isClean(); - String originUrl = git.getRepository().getConfig().getString("remote", "origin", - "url"); + String originUrl = git.getRepository().getConfig().getString("remote", "origin", "url"); if (this.forcePull && !isWorkingTreeClean) { shouldPull = true; logDirty(gitStatus); - } - else { + } else { shouldPull = isWorkingTreeClean && originUrl != null; } if (!isWorkingTreeClean && !this.forcePull) { - this.logger.info("Cannot pull from remote " + originUrl - + ", the working tree is not clean."); + this.logger.info("Cannot pull from remote " + originUrl + ", the working tree is not clean."); } return shouldPull; } @SuppressWarnings("unchecked") private void logDirty(Status status) { - Set dirties = dirties(status.getAdded(), status.getChanged(), - status.getRemoved(), status.getMissing(), status.getModified(), - status.getConflicting(), status.getUntracked()); + Set dirties = dirties(status.getAdded(), status.getChanged(), status.getRemoved(), status.getMissing(), + status.getModified(), status.getConflicting(), status.getUntracked()); this.logger.warn(String.format("Dirty files found: %s", dirties)); } @@ -314,15 +301,14 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository configureCommand(fetch); try { FetchResult result = fetch.call(); - if(result.getTrackingRefUpdates() != null && result.getTrackingRefUpdates().size() > 0) { + if (result.getTrackingRefUpdates() != null && result.getTrackingRefUpdates().size() > 0) { logger.info("Fetched for remote " + label + " and found " + result.getTrackingRefUpdates().size() - + " updates"); + + " updates"); } return result; - } - catch (Exception ex) { - String message = "Could not fetch remote for " + label + " remote: " + git - .getRepository().getConfig().getString("remote", "origin", "url"); + } catch (Exception ex) { + String message = "Could not fetch remote for " + label + " remote: " + + git.getRepository().getConfig().getString("remote", "origin", "url"); warn(message, ex); return null; } @@ -331,16 +317,15 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository private MergeResult merge(Git git, String label) { try { MergeCommand merge = git.merge(); - merge.include(git.getRepository().getRef("origin/" + label)); + merge.include(git.getRepository().findRef("origin/" + label)); MergeResult result = merge.call(); - if(!result.getMergeStatus().isSuccessful()) { + if (!result.getMergeStatus().isSuccessful()) { this.logger.warn("Merged from remote " + label + " with result " + result.getMergeStatus()); } return result; - } - catch (Exception ex) { - String message = "Could not merge remote for " + label + " remote: " + git - .getRepository().getConfig().getString("remote", "origin", "url"); + } catch (Exception ex) { + String message = "Could not merge remote for " + label + " remote: " + + git.getRepository().getConfig().getString("remote", "origin", "url"); warn(message, ex); return null; } @@ -352,31 +337,38 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository reset.setMode(ResetType.HARD); try { Ref resetRef = reset.call(); - if(resetRef != null) { + if (resetRef != null) { this.logger.info("Reset label " + label + " to version " + resetRef.getObjectId()); } return resetRef; - } - catch (Exception ex) { - String message = "Could not reset to remote for " + label + " (current ref=" - + ref + "), remote: " + git.getRepository().getConfig() - .getString("remote", "origin", "url"); + } catch (Exception ex) { + String message = "Could not reset to remote for " + label + " (current ref=" + ref + "), remote: " + + git.getRepository().getConfig().getString("remote", "origin", "url"); warn(message, ex); return null; } } private Git createGitClient() throws IOException, GitAPIException { - if (new File(getBasedir(), ".git").exists()) { - return openGitRepository(); + File lock = new File(getWorkingDirectory(), ".git/index.lock"); + if (lock.exists()) { + // The only way this can happen is if another JVM (e.g. one that + // crashed earlier) created the lock. We can attempt to recover by + // wiping the slate clean. + logger.info("Deleting stale JGit lock file at " + lock); + lock.delete(); } - else { + if (new File(getWorkingDirectory(), ".git").exists()) { + return openGitRepository(); + } else { return copyRepository(); } } - // Synchronize here so that multiple requests don't all try and delete the base dir - // together (this is a once only operation, so it only holds things up on the first + // Synchronize here so that multiple requests don't all try and delete the + // base dir + // together (this is a once only operation, so it only holds things up on + // the first // request). private synchronized Git copyRepository() throws IOException, GitAPIException { deleteBaseDirIfExists(); @@ -384,8 +376,7 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository Assert.state(getBasedir().exists(), "Could not create basedir: " + getBasedir()); if (getUri().startsWith(FILE_URI_PREFIX)) { return copyFromLocalRepository(); - } - else { + } else { return cloneToBasedir(); } } @@ -407,13 +398,12 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository } private Git cloneToBasedir() throws GitAPIException { - CloneCommand clone = this.gitFactory.getCloneCommandByCloneRepository() - .setURI(getUri()).setDirectory(getBasedir()); + CloneCommand clone = this.gitFactory.getCloneCommandByCloneRepository().setURI(getUri()) + .setDirectory(getBasedir()); configureCommand(clone); try { return clone.call(); - } - catch (GitAPIException e) { + } catch (GitAPIException e) { deleteBaseDirIfExists(); throw e; } @@ -423,8 +413,7 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository if (getBasedir().exists()) { try { FileUtils.delete(getBasedir(), FileUtils.RECURSIVE); - } - catch (IOException e) { + } catch (IOException e) { throw new IllegalStateException("Failed to initialize base directory", e); } } @@ -473,8 +462,7 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository StatusCommand status = git.status(); try { return status.call().isClean(); - } - catch (Exception e) { + } catch (Exception e) { String message = "Could not execute status command on local repository. Cause: (" + e.getClass().getSimpleName() + ") " + e.getMessage(); warn(message, e); @@ -483,8 +471,7 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository } private void trackBranch(Git git, CheckoutCommand checkout, String label) { - checkout.setCreateBranch(true).setName(label) - .setUpstreamMode(SetupUpstreamMode.TRACK) + checkout.setCreateBranch(true).setName(label).setUpstreamMode(SetupUpstreamMode.TRACK) .setStartPoint("origin/" + label); } @@ -496,8 +483,7 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository return containsBranch(git, label, null); } - private boolean containsBranch(Git git, String label, ListMode listMode) - throws GitAPIException { + private boolean containsBranch(Git git, String label, ListMode listMode) throws GitAPIException { ListBranchCommand command = git.branchList(); if (listMode != null) { command.setListMode(listMode); @@ -520,7 +506,8 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository /** * Wraps the static method calls to {@link org.eclipse.jgit.api.Git} and - * {@link org.eclipse.jgit.api.CloneCommand} allowing for easier unit testing. + * {@link org.eclipse.jgit.api.CloneCommand} allowing for easier unit + * testing. */ static class JGitFactory { @@ -543,7 +530,8 @@ public class JGitEnvironmentRepository extends AbstractScmEnvironmentRepository } /** - * @param gitCredentialsProvider the gitCredentialsProvider to set + * @param gitCredentialsProvider + * the gitCredentialsProvider to set */ public void setGitCredentialsProvider(CredentialsProvider gitCredentialsProvider) { this.gitCredentialsProvider = gitCredentialsProvider; diff --git a/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/AdhocTestSuite.java b/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/AdhocTestSuite.java new file mode 100644 index 00000000..4749750f --- /dev/null +++ b/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/AdhocTestSuite.java @@ -0,0 +1,25 @@ +package org.springframework.cloud.config.server; + +import org.junit.Ignore; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; +import org.springframework.cloud.config.server.environment.EnvironmentEncryptorEnvironmentRepositoryTests; +import org.springframework.cloud.config.server.environment.JGitEnvironmentRepositoryIntegrationTests; +import org.springframework.cloud.config.server.environment.MultipleJGitEnvironmentRepositoryIntegrationTests; +import org.springframework.cloud.config.server.environment.NativeEnvironmentRepositoryTests; +import org.springframework.cloud.config.server.environment.SVNKitEnvironmentRepositoryIntegrationTests; + +/** + * A test suite for probing weird ordering problems in the tests. + * + * @author Dave Syer + */ +@RunWith(Suite.class) +@SuiteClasses({ MultipleJGitEnvironmentRepositoryIntegrationTests.class, + JGitEnvironmentRepositoryIntegrationTests.class, EnvironmentEncryptorEnvironmentRepositoryTests.class, + NativeEnvironmentRepositoryTests.class, SVNKitEnvironmentRepositoryIntegrationTests.class }) +@Ignore +public class AdhocTestSuite { + +} diff --git a/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepositoryIntegrationTests.java b/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepositoryIntegrationTests.java index 6f3d2653..60b38ce3 100644 --- a/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepositoryIntegrationTests.java +++ b/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepositoryIntegrationTests.java @@ -16,6 +16,14 @@ package org.springframework.cloud.config.server.environment; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + import java.io.File; import java.io.FileOutputStream; import java.io.IOException; @@ -41,7 +49,7 @@ import org.junit.After; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; -import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration; +import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration; import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.cloud.config.environment.Environment; @@ -52,17 +60,10 @@ import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; +import org.springframework.util.FileSystemUtils; import org.springframework.util.ResourceUtils; import org.springframework.util.StreamUtils; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.assertTrue; - /** * @author Dave Syer * @author Roy Clarkson @@ -95,8 +96,7 @@ public class JGitEnvironmentRepositoryIntegrationTests { String uri = ConfigServerTestUtils.prepareLocalRepo(); this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) .properties("spring.cloud.config.server.git.uri:" + uri).run(); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("bar", "staging", "master"); Environment environment = repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); @@ -111,12 +111,10 @@ public class JGitEnvironmentRepositoryIntegrationTests { String uri = ConfigServerTestUtils.copyLocalRepo("config-copy"); this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) .run("--spring.cloud.config.server.git.uri=" + uri); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("bar", "staging", "master"); Environment environment = repository.findOne("bar", "staging", "master"); - assertEquals("bar", - environment.getPropertySources().get(0).getSource().get("foo")); + assertEquals("bar", environment.getPropertySources().get(0).getSource().get("foo")); Git git = Git.open(ResourceUtils.getFile(uri).getAbsoluteFile()); git.checkout().setName("master").call(); StreamUtils.copy("foo: foo", Charset.defaultCharset(), @@ -124,15 +122,14 @@ public class JGitEnvironmentRepositoryIntegrationTests { git.add().addFilepattern("bar.properties").call(); git.commit().setMessage("Updated for pull").call(); environment = repository.findOne("bar", "staging", "master"); - assertEquals("foo", - environment.getPropertySources().get(0).getSource().get("foo")); + assertEquals("foo", environment.getPropertySources().get(0).getSource().get("foo")); } /** - * Tests a special use case where the remote repository has been updated with a forced - * push conflicting with the local repo of the Config Server. The Config Server has to - * reset hard on the new reference because a simple pull operation could result in a - * conflicting local repository. + * Tests a special use case where the remote repository has been updated + * with a forced push conflicting with the local repo of the Config Server. + * The Config Server has to reset hard on the new reference because a simple + * pull operation could result in a conflicting local repository. */ @Test public void pullDirtyRepo() throws Exception { @@ -144,23 +141,19 @@ public class JGitEnvironmentRepositoryIntegrationTests { Git git = Git.open(ResourceUtils.getFile(uri).getAbsoluteFile()); StoredConfig config = git.getRepository().getConfig(); - config.setString("remote", "origin", "url", - remote.getDirectory().getAbsolutePath()); - config.setString("remote", "origin", "fetch", - "+refs/heads/*:refs/remotes/origin/*"); + config.setString("remote", "origin", "url", remote.getDirectory().getAbsolutePath()); + config.setString("remote", "origin", "fetch", "+refs/heads/*:refs/remotes/origin/*"); config.save(); // Pushes the raw branch to remote repository. git.push().call(); - String commitToRevertBeforePull = git.log().setMaxCount(1).call().iterator() - .next().getName(); + String commitToRevertBeforePull = git.log().setMaxCount(1).call().iterator().next().getName(); this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) .run("--spring.cloud.config.server.git.uri=" + uri); - JGitEnvironmentRepository repository = this.context - .getBean(JGitEnvironmentRepository.class); + JGitEnvironmentRepository repository = this.context.getBean(JGitEnvironmentRepository.class); // Fetches the repository for the first time. SearchPathLocator.Locations locations = repository.getLocations("bar", "test", "raw"); @@ -170,17 +163,14 @@ public class JGitEnvironmentRepositoryIntegrationTests { git.reset().setMode(ResetType.HARD).setRef("master").call(); // Generate a conflicting commit who will be forced on the origin. - Path applicationFilePath = Paths - .get(ResourceUtils.getFile(uri).getAbsoluteFile() + "/application.yml"); + Path applicationFilePath = Paths.get(ResourceUtils.getFile(uri).getAbsoluteFile() + "/application.yml"); - Files.write(applicationFilePath, - Arrays.asList("info:", " foo: bar", "raw: false"), - StandardCharsets.UTF_8, StandardOpenOption.TRUNCATE_EXISTING); + Files.write(applicationFilePath, Arrays.asList("info:", " foo: bar", "raw: false"), StandardCharsets.UTF_8, + StandardOpenOption.TRUNCATE_EXISTING); git.add().addFilepattern(".").call(); git.commit().setMessage("Conflicting commit.").call(); git.push().setForce(true).call(); - String conflictingCommit = git.log().setMaxCount(1).call().iterator() - .next().getName(); + String conflictingCommit = git.log().setMaxCount(1).call().iterator().next().getName(); // Reset to the raw branch. git.reset().setMode(ResetType.HARD).setRef(commitToRevertBeforePull).call(); @@ -189,8 +179,17 @@ public class JGitEnvironmentRepositoryIntegrationTests { locations = repository.getLocations("bar", "test", "raw"); assertEquals(locations.getVersion(), conflictingCommit); - assertTrue("Local repository is not cleaned after retrieving resources.", - git.status().call().isClean()); + assertTrue("Local repository is not cleaned after retrieving resources.", git.status().call().isClean()); + } + + @Test + public void pullMissingRepo() throws Exception { + pull(); + JGitEnvironmentRepository repository = this.context.getBean(JGitEnvironmentRepository.class); + new File(repository.getUri().replaceAll("file:", ""), ".git/index.lock").createNewFile(); + repository.findOne("bar", "staging", "master"); + Environment environment = repository.findOne("bar", "staging", "master"); + assertEquals("foo", environment.getPropertySources().get(0).getSource().get("foo")); } @Test @@ -198,10 +197,8 @@ public class JGitEnvironmentRepositoryIntegrationTests { String uri = ConfigServerTestUtils.prepareLocalRepo("another-config-repo"); this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) // TODO: why didn't .properties() work for me? - .run("--spring.cloud.config.server.git.uri=" + uri, - "--spring.cloud.config.server.git.searchPaths=sub"); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + .run("--spring.cloud.config.server.git.uri=" + uri, "--spring.cloud.config.server.git.searchPaths=sub"); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("bar", "staging", "master"); Environment environment = repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); @@ -214,8 +211,7 @@ public class JGitEnvironmentRepositoryIntegrationTests { // TODO: why didn't .properties() work for me? .run("--spring.cloud.config.server.git.uri=" + uri, "--spring.cloud.config.server.git.searchPaths={application}"); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("foo,bar", "staging", "master"); Environment environment = repository.findOne("foo,bar", "staging", "master"); assertEquals(3, environment.getPropertySources().size()); @@ -228,8 +224,7 @@ public class JGitEnvironmentRepositoryIntegrationTests { // TODO: why didn't .properties() work for me? .run("--spring.cloud.config.server.git.uri=" + uri, "--spring.cloud.config.server.git.searchPaths={profile}"); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("foo,bar", "staging", "master"); Environment environment = repository.findOne("staging", "foo,bar", "master"); assertEquals(3, environment.getPropertySources().size()); @@ -238,15 +233,13 @@ public class JGitEnvironmentRepositoryIntegrationTests { @Test public void singleElementArrayIndexSearchPath() throws IOException { String uri = ConfigServerTestUtils.prepareLocalRepo("nested-repo"); - this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) - .run("--spring.cloud.config.server.git.uri=" + uri, - "--spring.cloud.config.server.git.searchPaths[0]={application}"); - JGitEnvironmentRepository repository = this.context - .getBean(JGitEnvironmentRepository.class); + this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false).run( + "--spring.cloud.config.server.git.uri=" + uri, + "--spring.cloud.config.server.git.searchPaths[0]={application}"); + JGitEnvironmentRepository repository = this.context.getBean(JGitEnvironmentRepository.class); assertThat(repository.getSearchPaths(), Matchers.arrayContaining("{application}")); assertFalse(Arrays.equals(repository.getSearchPaths(), - new JGitEnvironmentRepository(repository.getEnvironment()) - .getSearchPaths())); + new JGitEnvironmentRepository(repository.getEnvironment()).getSearchPaths())); } @Test @@ -254,8 +247,7 @@ public class JGitEnvironmentRepositoryIntegrationTests { String uri = ConfigServerTestUtils.prepareLocalRepo(); this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) .properties("spring.cloud.config.server.git.uri:" + uri).run(); - JGitEnvironmentRepository repository = this.context - .getBean(JGitEnvironmentRepository.class); + JGitEnvironmentRepository repository = this.context.getBean(JGitEnvironmentRepository.class); assertEquals("master", repository.getDefaultLabel()); } @@ -264,8 +256,7 @@ public class JGitEnvironmentRepositoryIntegrationTests { String uri = ConfigServerTestUtils.prepareLocalRepo(); this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) .properties("spring.cloud.config.server.git.uri:" + uri).run(); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("bar", "staging", "unknownlabel"); } @@ -273,11 +264,9 @@ public class JGitEnvironmentRepositoryIntegrationTests { public void findOne_CloneOnStartTrue_FindOneSuccess() throws Exception { ConfigServerTestUtils.prepareLocalRepo(); String uri = ConfigServerTestUtils.copyLocalRepo("config-copy"); - this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) - .run("--spring.cloud.config.server.git.uri=" + uri, - "--spring.cloud.config.server.git.cloneOnStart=true"); - EnvironmentRepository repository = this.context - .getBean(JGitEnvironmentRepository.class); + this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false).run( + "--spring.cloud.config.server.git.uri=" + uri, "--spring.cloud.config.server.git.cloneOnStart=true"); + EnvironmentRepository repository = this.context.getBean(JGitEnvironmentRepository.class); assertTrue(((JGitEnvironmentRepository) repository).isCloneOnStart()); Environment environment = repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); @@ -290,15 +279,12 @@ public class JGitEnvironmentRepositoryIntegrationTests { public void findOne_FileAddedToRepo_FindOneSuccess() throws Exception { ConfigServerTestUtils.prepareLocalRepo(); String uri = ConfigServerTestUtils.copyLocalRepo("config-copy"); - this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) - .run("--spring.cloud.config.server.git.uri=" + uri, - "--spring.cloud.config.server.git.cloneOnStart=true"); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false).run( + "--spring.cloud.config.server.git.uri=" + uri, "--spring.cloud.config.server.git.cloneOnStart=true"); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("bar", "staging", "master"); Environment environment = repository.findOne("bar", "staging", "master"); - assertEquals("bar", - environment.getPropertySources().get(0).getSource().get("foo")); + assertEquals("bar", environment.getPropertySources().get(0).getSource().get("foo")); Git git = Git.open(ResourceUtils.getFile(uri).getAbsoluteFile()); git.checkout().setName("master").call(); StreamUtils.copy("foo: foo", Charset.defaultCharset(), @@ -306,8 +292,7 @@ public class JGitEnvironmentRepositoryIntegrationTests { git.add().addFilepattern("bar.properties").call(); git.commit().setMessage("Updated for pull").call(); environment = repository.findOne("bar", "staging", "master"); - assertEquals("foo", - environment.getPropertySources().get(0).getSource().get("foo")); + assertEquals("foo", environment.getPropertySources().get(0).getSource().get("foo")); } @Test @@ -315,83 +300,80 @@ public class JGitEnvironmentRepositoryIntegrationTests { String uri = ConfigServerTestUtils.prepareLocalRepo("another-config-repo"); this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) // TODO: why didn't .properties() work for me? - .run("--spring.cloud.config.server.git.uri=" + uri, - "--spring.cloud.config.server.git.searchPaths=sub", + .run("--spring.cloud.config.server.git.uri=" + uri, "--spring.cloud.config.server.git.searchPaths=sub", "--spring.cloud.config.server.git.cloneOnStart=true"); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("bar", "staging", "master"); Environment environment = repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); } @Test(expected = NoSuchLabelException.class) - public void findOne_FindInvalidLabel_IllegalStateExceptionThrown() - throws IOException { + public void findOne_FindInvalidLabel_IllegalStateExceptionThrown() throws IOException { String uri = ConfigServerTestUtils.prepareLocalRepo(); this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) .properties("spring.cloud.config.server.git.uri:" + uri, "--spring.cloud.config.server.git.cloneOnStart=true") .run(); - EnvironmentRepository repository = this.context - .getBean(EnvironmentRepository.class); + EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class); repository.findOne("bar", "staging", "unknownlabel"); } @Test public void testVersionUpdate() throws Exception { - JGitConfigServerTestData testData = JGitConfigServerTestData.prepareClonedGitRepository(TestConfiguration.class); + JGitConfigServerTestData testData = JGitConfigServerTestData + .prepareClonedGitRepository(TestConfiguration.class); - //get our starting versions + // get our starting versions String startingLocalVersion = getCommitID(testData.getClonedGit().getGit(), "master"); String startingRemoteVersion = getCommitID(testData.getServerGit().getGit(), "master"); - //make sure we get the right version out of the gate + // make sure we get the right version out of the gate Environment environment = testData.getRepository().findOne("bar", "staging", "master"); - //make sure the environments version is the same as the remote repo version + // make sure the environments version is the same as the remote repo + // version assertEquals(environment.getVersion(), startingRemoteVersion); - //update the remote repo - FileOutputStream out = new FileOutputStream(new File(testData.getServerGit().getGitWorkingDirectory(), "bar.properties")); + // update the remote repo + FileOutputStream out = new FileOutputStream( + new File(testData.getServerGit().getGitWorkingDirectory(), "bar.properties")); StreamUtils.copy("foo: foo", Charset.defaultCharset(), out); testData.getServerGit().getGit().add().addFilepattern("bar.properties").call(); testData.getServerGit().getGit().commit().setMessage("Updated for pull").call(); - //pull the environment again which should update the local repo from the just updated remote repo + // pull the environment again which should update the local repo from + // the just updated remote repo environment = testData.getRepository().findOne("bar", "staging", "master"); - //do some more check outs to get updated version numbers + // do some more check outs to get updated version numbers String updatedLocalVersion = getCommitID(testData.getClonedGit().getGit(), "master"); String updatedRemoteVersion = getCommitID(testData.getClonedGit().getGit(), "master"); - //make sure our versions have been updated + // make sure our versions have been updated assertEquals(updatedRemoteVersion, updatedLocalVersion); assertNotEquals(updatedRemoteVersion, startingRemoteVersion); assertNotEquals(updatedLocalVersion, startingLocalVersion); - //make sure our environment also reflects the updated version - //this used to have a bug + // make sure our environment also reflects the updated version + // this used to have a bug assertEquals(environment.getVersion(), updatedRemoteVersion); } @Test public void testNewRemoteBranch() throws Exception { - JGitConfigServerTestData testData = JGitConfigServerTestData.prepareClonedGitRepository(TestConfiguration.class); + JGitConfigServerTestData testData = JGitConfigServerTestData + .prepareClonedGitRepository(TestConfiguration.class); Environment environment = testData.getRepository().findOne("bar", "staging", "master"); Object fooProperty = ConfigServerTestUtils.getProperty(environment, "bar.properties", "foo"); assertEquals(fooProperty, "bar"); - testData.getServerGit().getGit().branchCreate() - .setName("testNewRemoteBranch") - .call(); + testData.getServerGit().getGit().branchCreate().setName("testNewRemoteBranch").call(); - testData.getServerGit().getGit().checkout() - .setName("testNewRemoteBranch") - .call(); + testData.getServerGit().getGit().checkout().setName("testNewRemoteBranch").call(); - //update the remote repo + // update the remote repo FileOutputStream out = new FileOutputStream( new File(testData.getServerGit().getGitWorkingDirectory(), "/bar.properties")); StreamUtils.copy("foo: branchBar", Charset.defaultCharset(), out); @@ -405,7 +387,8 @@ public class JGitEnvironmentRepositoryIntegrationTests { @Test public void testNewRemoteTag() throws Exception { - JGitConfigServerTestData testData = JGitConfigServerTestData.prepareClonedGitRepository(TestConfiguration.class); + JGitConfigServerTestData testData = JGitConfigServerTestData + .prepareClonedGitRepository(TestConfiguration.class); Git serverGit = testData.getServerGit().getGit(); @@ -415,10 +398,10 @@ public class JGitEnvironmentRepositoryIntegrationTests { serverGit.checkout().setName("master").call(); - //create a new tag + // create a new tag serverGit.tag().setName("testTag").setMessage("Testing a tag").call(); - //update the remote repo + // update the remote repo FileOutputStream out = new FileOutputStream( new File(testData.getServerGit().getGitWorkingDirectory(), "/bar.properties")); StreamUtils.copy("foo: testAfterTag", Charset.defaultCharset(), out); @@ -433,50 +416,52 @@ public class JGitEnvironmentRepositoryIntegrationTests { fooProperty = ConfigServerTestUtils.getProperty(environment, "bar.properties", "foo"); assertEquals(fooProperty, "bar"); - //now move the tag and test again - serverGit.tag().setName("testTag").setForceUpdate(true).setMessage("Testing a moved tag").call(); + // now move the tag and test again + serverGit.tag().setName("testTag").setForceUpdate(true).setMessage("Testing a moved tag").call(); - environment = testData.getRepository().findOne("bar", "staging", "testTag"); - fooProperty = ConfigServerTestUtils.getProperty(environment, "bar.properties", "foo"); - assertEquals(fooProperty, "testAfterTag"); + environment = testData.getRepository().findOne("bar", "staging", "testTag"); + fooProperty = ConfigServerTestUtils.getProperty(environment, "bar.properties", "foo"); + assertEquals(fooProperty, "testAfterTag"); } - @Test + @Test public void testNewCommitID() throws Exception { - JGitConfigServerTestData testData = JGitConfigServerTestData.prepareClonedGitRepository(TestConfiguration.class); + JGitConfigServerTestData testData = JGitConfigServerTestData + .prepareClonedGitRepository(TestConfiguration.class); - //get our starting versions + // get our starting versions String startingRemoteVersion = getCommitID(testData.getServerGit().getGit(), "master"); - //make sure we get the right version out of the gate + // make sure we get the right version out of the gate Environment environment = testData.getRepository().findOne("bar", "staging", "master"); assertEquals(environment.getVersion(), startingRemoteVersion); - //update the remote repo - FileOutputStream out = new FileOutputStream(new File(testData.getServerGit().getGitWorkingDirectory(), "bar.properties")); + // update the remote repo + FileOutputStream out = new FileOutputStream( + new File(testData.getServerGit().getGitWorkingDirectory(), "bar.properties")); StreamUtils.copy("foo: barNewCommit", Charset.defaultCharset(), out); testData.getServerGit().getGit().add().addFilepattern("bar.properties").call(); testData.getServerGit().getGit().commit().setMessage("Updated for pull").call(); String updatedRemoteVersion = getCommitID(testData.getServerGit().getGit(), "master"); - //do a normal request and verify we get the new version + // do a normal request and verify we get the new version environment = testData.getRepository().findOne("bar", "staging", "master"); assertEquals(environment.getVersion(), updatedRemoteVersion); Object fooProperty = ConfigServerTestUtils.getProperty(environment, "bar.properties", "foo"); assertEquals(fooProperty, "barNewCommit"); - //request the prior commit ID and make sure we get it + // request the prior commit ID and make sure we get it environment = testData.getRepository().findOne("bar", "staging", startingRemoteVersion); assertEquals(environment.getVersion(), startingRemoteVersion); fooProperty = ConfigServerTestUtils.getProperty(environment, "bar.properties", "foo"); assertEquals(fooProperty, "bar"); } - @Test(expected = NoSuchLabelException.class) public void testUnknownLabelWithRemote() throws Exception { - JGitConfigServerTestData testData = JGitConfigServerTestData.prepareClonedGitRepository(TestConfiguration.class); + JGitConfigServerTestData testData = JGitConfigServerTestData + .prepareClonedGitRepository(TestConfiguration.class); testData.getRepository().findOne("bar", "staging", "BADLabel"); } @@ -490,9 +475,9 @@ public class JGitEnvironmentRepositoryIntegrationTests { public void passphrase() throws IOException { String uri = ConfigServerTestUtils.prepareLocalRepo("config-repo"); final String passphrase = "thisismypassphrase"; - this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) - .run("--spring.cloud.config.server.git.uri=" + uri, - "--spring.cloud.config.server.git.passphrase=" + passphrase); + this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false).run( + "--spring.cloud.config.server.git.uri=" + uri, + "--spring.cloud.config.server.git.passphrase=" + passphrase); JGitEnvironmentRepository repository = this.context.getBean(JGitEnvironmentRepository.class); assertThat(repository.getPassphrase(), Matchers.containsString(passphrase)); } @@ -501,9 +486,9 @@ public class JGitEnvironmentRepositoryIntegrationTests { public void strictHostKeyChecking() throws IOException { String uri = ConfigServerTestUtils.prepareLocalRepo("config-repo"); final boolean strictHostKeyChecking = true; - this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false) - .run("--spring.cloud.config.server.git.uri=" + uri, - "--spring.cloud.config.server.git.strict-host-key-checking=" + strictHostKeyChecking); + this.context = new SpringApplicationBuilder(TestConfiguration.class).web(false).run( + "--spring.cloud.config.server.git.uri=" + uri, + "--spring.cloud.config.server.git.strict-host-key-checking=" + strictHostKeyChecking); JGitEnvironmentRepository repository = this.context.getBean(JGitEnvironmentRepository.class); assertEquals(repository.isStrictHostKeyChecking(), strictHostKeyChecking); } @@ -511,10 +496,8 @@ public class JGitEnvironmentRepositoryIntegrationTests { @Test public void shouldSetTransportConfigCallback() throws IOException { String uri = ConfigServerTestUtils.prepareLocalRepo(); - this.context = new SpringApplicationBuilder(TestConfigurationWithTransportConfigCallback.class) - .web(false) - .properties("spring.cloud.config.server.git.uri:" + uri) - .run(); + this.context = new SpringApplicationBuilder(TestConfigurationWithTransportConfigCallback.class).web(false) + .properties("spring.cloud.config.server.git.uri:" + uri).run(); JGitEnvironmentRepository repository = this.context.getBean(JGitEnvironmentRepository.class); assertNotNull(repository.getTransportConfigCallback()); @@ -522,15 +505,13 @@ public class JGitEnvironmentRepositoryIntegrationTests { @Configuration @EnableConfigurationProperties(ConfigServerProperties.class) - @Import({ PropertyPlaceholderAutoConfiguration.class, - EnvironmentRepositoryConfiguration.class }) + @Import({ PropertyPlaceholderAutoConfiguration.class, EnvironmentRepositoryConfiguration.class }) protected static class TestConfiguration { } @Configuration @EnableConfigurationProperties(ConfigServerProperties.class) - @Import({ PropertyPlaceholderAutoConfiguration.class, - EnvironmentRepositoryConfiguration.class }) + @Import({ PropertyPlaceholderAutoConfiguration.class, EnvironmentRepositoryConfiguration.class }) protected static class TestConfigurationWithTransportConfigCallback { @Bean diff --git a/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepositoryTests.java b/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepositoryTests.java index f8b430cd..ef105132 100644 --- a/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepositoryTests.java +++ b/spring-cloud-config-server/src/test/java/org/springframework/cloud/config/server/environment/JGitEnvironmentRepositoryTests.java @@ -16,6 +16,21 @@ package org.springframework.cloud.config.server.environment; +import static junit.framework.TestCase.assertTrue; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThat; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.mockingDetails; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import java.io.File; import java.io.IOException; import java.lang.reflect.Method; @@ -48,6 +63,7 @@ import org.eclipse.jgit.transport.FetchResult; import org.eclipse.jgit.transport.JschConfigSessionFactory; import org.eclipse.jgit.transport.OpenSshConfig; import org.eclipse.jgit.transport.SshSessionFactory; +import org.eclipse.jgit.transport.TrackingRefUpdate; import org.eclipse.jgit.transport.URIish; import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider; import org.eclipse.jgit.util.FS; @@ -66,21 +82,6 @@ import org.springframework.core.env.StandardEnvironment; import com.jcraft.jsch.Session; -import static junit.framework.TestCase.assertTrue; -import static org.hamcrest.Matchers.is; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertThat; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyString; -import static org.mockito.Matchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.mockingDetails; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - /** * @author Dave Syer * @@ -88,8 +89,7 @@ import static org.mockito.Mockito.when; public class JGitEnvironmentRepositoryTests { private StandardEnvironment environment = new StandardEnvironment(); - private JGitEnvironmentRepository repository = new JGitEnvironmentRepository( - this.environment); + private JGitEnvironmentRepository repository = new JGitEnvironmentRepository(this.environment); private File basedir = new File("target/config"); @@ -110,8 +110,7 @@ public class JGitEnvironmentRepositoryTests { this.repository.findOne("bar", "staging", "master"); Environment environment = this.repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); - assertEquals(this.repository.getUri() + "/bar.properties", - environment.getPropertySources().get(0).getName()); + assertEquals(this.repository.getUri() + "/bar.properties", environment.getPropertySources().get(0).getName()); assertVersion(environment); } @@ -119,7 +118,7 @@ public class JGitEnvironmentRepositoryTests { public void nested() throws IOException { String uri = ConfigServerTestUtils.prepareLocalRepo("another-config-repo"); this.repository.setUri(uri); - this.repository.setSearchPaths(new String[] {"sub"}); + this.repository.setSearchPaths(new String[] { "sub" }); this.repository.findOne("bar", "staging", "master"); Environment environment = this.repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); @@ -132,7 +131,7 @@ public class JGitEnvironmentRepositoryTests { public void placeholderInSearchPath() throws IOException { String uri = ConfigServerTestUtils.prepareLocalRepo("another-config-repo"); this.repository.setUri(uri); - this.repository.setSearchPaths(new String[] {"{application}"}); + this.repository.setSearchPaths(new String[] { "{application}" }); this.repository.findOne("sub", "staging", "master"); Environment environment = this.repository.findOne("sub", "staging", "master"); assertEquals(1, environment.getPropertySources().size()); @@ -151,7 +150,7 @@ public class JGitEnvironmentRepositoryTests { public void nestedPattern() throws IOException { String uri = ConfigServerTestUtils.prepareLocalRepo("another-config-repo"); this.repository.setUri(uri); - this.repository.setSearchPaths(new String[] {"sub*"}); + this.repository.setSearchPaths(new String[] { "sub*" }); this.repository.findOne("bar", "staging", "master"); Environment environment = this.repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); @@ -165,8 +164,7 @@ public class JGitEnvironmentRepositoryTests { this.repository.setBasedir(this.basedir); Environment environment = this.repository.findOne("bar", "staging", "raw"); assertEquals(2, environment.getPropertySources().size()); - assertEquals(this.repository.getUri() + "/bar.properties", - environment.getPropertySources().get(0).getName()); + assertEquals(this.repository.getUri() + "/bar.properties", environment.getPropertySources().get(0).getName()); assertVersion(environment); } @@ -175,8 +173,7 @@ public class JGitEnvironmentRepositoryTests { this.repository.setBasedir(this.basedir); Environment environment = this.repository.findOne("bar", "staging", "foo"); assertEquals(2, environment.getPropertySources().size()); - assertEquals(this.repository.getUri() + "/bar.properties", environment - .getPropertySources().get(0).getName()); + assertEquals(this.repository.getUri() + "/bar.properties", environment.getPropertySources().get(0).getName()); assertVersion(environment); } @@ -186,8 +183,7 @@ public class JGitEnvironmentRepositoryTests { this.repository.findOne("bar", "staging", "master"); Environment environment = this.repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); - assertEquals(this.repository.getUri() + "/bar.properties", - environment.getPropertySources().get(0).getName()); + assertEquals(this.repository.getUri() + "/bar.properties", environment.getPropertySources().get(0).getName()); assertVersion(environment); } @@ -199,8 +195,7 @@ public class JGitEnvironmentRepositoryTests { this.repository.findOne("bar", "staging", "master"); Environment environment = this.repository.findOne("bar", "staging", "master"); assertEquals(2, environment.getPropertySources().size()); - assertEquals(this.repository.getUri() + "/bar.properties", - environment.getPropertySources().get(0).getName()); + assertEquals(this.repository.getUri() + "/bar.properties", environment.getPropertySources().get(0).getName()); assertVersion(environment); } @@ -217,16 +212,14 @@ public class JGitEnvironmentRepositoryTests { } @Test - public void afterPropertiesSet_CloneOnStartTrue_CloneAndFetchCalled() - throws Exception { + public void afterPropertiesSet_CloneOnStartTrue_CloneAndFetchCalled() throws Exception { Git mockGit = mock(Git.class); CloneCommand mockCloneCommand = mock(CloneCommand.class); when(mockCloneCommand.setURI(anyString())).thenReturn(mockCloneCommand); when(mockCloneCommand.setDirectory(any(File.class))).thenReturn(mockCloneCommand); - JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository( - this.environment); + JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository(this.environment); envRepository.setGitFactory(new MockGitFactory(mockGit, mockCloneCommand)); envRepository.setUri("http://somegitserver/somegitrepo"); envRepository.setCloneOnStart(true); @@ -235,16 +228,14 @@ public class JGitEnvironmentRepositoryTests { } @Test - public void afterPropertiesSet_CloneOnStartFalse_CloneAndFetchNotCalled() - throws Exception { + public void afterPropertiesSet_CloneOnStartFalse_CloneAndFetchNotCalled() throws Exception { Git mockGit = mock(Git.class); CloneCommand mockCloneCommand = mock(CloneCommand.class); when(mockCloneCommand.setURI(anyString())).thenReturn(mockCloneCommand); when(mockCloneCommand.setDirectory(any(File.class))).thenReturn(mockCloneCommand); - JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository( - this.environment); + JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository(this.environment); envRepository.setGitFactory(new MockGitFactory(mockGit, mockCloneCommand)); envRepository.setUri("http://somegitserver/somegitrepo"); envRepository.afterPropertiesSet(); @@ -253,16 +244,14 @@ public class JGitEnvironmentRepositoryTests { } @Test - public void afterPropertiesSet_CloneOnStartTrueWithFileURL_CloneAndFetchNotCalled() - throws Exception { + public void afterPropertiesSet_CloneOnStartTrueWithFileURL_CloneAndFetchNotCalled() throws Exception { Git mockGit = mock(Git.class); CloneCommand mockCloneCommand = mock(CloneCommand.class); when(mockCloneCommand.setURI(anyString())).thenReturn(mockCloneCommand); when(mockCloneCommand.setDirectory(any(File.class))).thenReturn(mockCloneCommand); - JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository( - this.environment); + JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository(this.environment); envRepository.setGitFactory(new MockGitFactory(mockGit, mockCloneCommand)); envRepository.setUri("file://somefilesystem/somegitrepo"); envRepository.setCloneOnStart(true); @@ -286,8 +275,7 @@ public class JGitEnvironmentRepositoryTests { when(statusCommand.call()).thenReturn(status); when(status.isClean()).thenReturn(false); - JGitEnvironmentRepository repo = new JGitEnvironmentRepository( - this.environment); + JGitEnvironmentRepository repo = new JGitEnvironmentRepository(this.environment); repo.setForcePull(true); boolean shouldPull = repo.shouldPull(git); @@ -310,8 +298,7 @@ public class JGitEnvironmentRepositoryTests { when(statusCommand.call()).thenReturn(status); when(status.isClean()).thenReturn(false); - JGitEnvironmentRepository repo = new JGitEnvironmentRepository( - this.environment); + JGitEnvironmentRepository repo = new JGitEnvironmentRepository(this.environment); boolean shouldPull = repo.shouldPull(git); @@ -333,8 +320,7 @@ public class JGitEnvironmentRepositoryTests { when(statusCommand.call()).thenReturn(status); when(status.isClean()).thenReturn(true); - JGitEnvironmentRepository repo = new JGitEnvironmentRepository( - this.environment); + JGitEnvironmentRepository repo = new JGitEnvironmentRepository(this.environment); boolean shouldPull = repo.shouldPull(git); @@ -347,11 +333,9 @@ public class JGitEnvironmentRepositoryTests { Git git = mock(Git.class); CloneCommand cloneCommand = mock(CloneCommand.class); MockGitFactory factory = new MockGitFactory(git, cloneCommand); - JGitEnvironmentRepository repo = new JGitEnvironmentRepository( - this.environment); this.repository.setGitFactory(factory); - //refresh()->shouldPull + // refresh()->shouldPull StatusCommand statusCommand = mock(StatusCommand.class); Status status = mock(Status.class); when(git.status()).thenReturn(statusCommand); @@ -363,15 +347,21 @@ public class JGitEnvironmentRepositoryTests { when(statusCommand.call()).thenReturn(status); when(status.isClean()).thenReturn(true); - //refresh()->fetch + // refresh()->fetch FetchCommand fetchCommand = mock(FetchCommand.class); when(git.fetch()).thenReturn(fetchCommand); when(fetchCommand.setRemote(anyString())).thenReturn(fetchCommand); - when(fetchCommand.call()).thenThrow(new InvalidRemoteException("invalid mock remote")); //here is our exception we are testing + when(fetchCommand.call()).thenThrow(new InvalidRemoteException("invalid mock remote")); // here + // is + // our + // exception + // we + // are + // testing - //refresh()->checkout + // refresh()->checkout CheckoutCommand checkoutCommand = mock(CheckoutCommand.class); - //refresh()->checkout->containsBranch + // refresh()->checkout->containsBranch ListBranchCommand listBranchCommand = mock(ListBranchCommand.class); when(git.checkout()).thenReturn(checkoutCommand); when(git.branchList()).thenReturn(listBranchCommand); @@ -381,20 +371,27 @@ public class JGitEnvironmentRepositoryTests { when(ref.getName()).thenReturn("/master"); when(listBranchCommand.call()).thenReturn(refs); - //refresh()->merge + // refresh()->merge MergeCommand mergeCommand = mock(MergeCommand.class); when(git.merge()).thenReturn(mergeCommand); - when(mergeCommand.call()).thenThrow(new NotMergedException()); //here is our exception we are testing + when(mergeCommand.call()).thenThrow(new NotMergedException()); // here + // is + // our + // exception + // we + // are + // testing - //refresh()->return git.getRepository().getRef("HEAD").getObjectId().getName(); + // refresh()->return + // git.getRepository().getRef("HEAD").getObjectId().getName(); Ref headRef = mock(Ref.class); - when(repository.getRef(anyString())).thenReturn(headRef); + when(repository.findRef(anyString())).thenReturn(headRef); - ObjectId newObjectId = ObjectId.fromRaw(new int[]{1,2,3,4,5}); + ObjectId newObjectId = ObjectId.fromRaw(new int[] { 1, 2, 3, 4, 5 }); when(headRef.getObjectId()).thenReturn(newObjectId); SearchPathLocator.Locations locations = this.repository.getLocations("bar", "staging", null); - assertEquals(locations.getVersion(),newObjectId.getName()); + assertEquals(locations.getVersion(), newObjectId.getName()); } @Test @@ -403,8 +400,6 @@ public class JGitEnvironmentRepositoryTests { Git git = mock(Git.class); CloneCommand cloneCommand = mock(CloneCommand.class); MockGitFactory factory = new MockGitFactory(git, cloneCommand); - JGitEnvironmentRepository repo = new JGitEnvironmentRepository( - this.environment); this.repository.setGitFactory(factory); //refresh()->shouldPull @@ -425,7 +420,7 @@ public class JGitEnvironmentRepositoryTests { when(git.fetch()).thenReturn(fetchCommand); when(fetchCommand.setRemote(anyString())).thenReturn(fetchCommand); when(fetchCommand.call()).thenReturn(fetchResult); - when(fetchResult.getTrackingRefUpdates()).thenReturn(Collections.EMPTY_LIST); + when(fetchResult.getTrackingRefUpdates()).thenReturn(Collections.emptyList()); //refresh()->checkout CheckoutCommand checkoutCommand = mock(CheckoutCommand.class); @@ -446,7 +441,7 @@ public class JGitEnvironmentRepositoryTests { //refresh()->return git.getRepository().getRef("HEAD").getObjectId().getName(); Ref headRef = mock(Ref.class); - when(repository.getRef(anyString())).thenReturn(headRef); + when(repository.findRef(anyString())).thenReturn(headRef); ObjectId newObjectId = ObjectId.fromRaw(new int[]{1,2,3,4,5}); when(headRef.getObjectId()).thenReturn(newObjectId); @@ -461,11 +456,9 @@ public class JGitEnvironmentRepositoryTests { Git git = mock(Git.class); CloneCommand cloneCommand = mock(CloneCommand.class); MockGitFactory factory = new MockGitFactory(git, cloneCommand); - JGitEnvironmentRepository repo = new JGitEnvironmentRepository( - this.environment); this.repository.setGitFactory(factory); - //refresh()->shouldPull + // refresh()->shouldPull StatusCommand statusCommand = mock(StatusCommand.class); Status status = mock(Status.class); when(git.status()).thenReturn(statusCommand); @@ -477,17 +470,17 @@ public class JGitEnvironmentRepositoryTests { when(statusCommand.call()).thenReturn(status); when(status.isClean()).thenReturn(true).thenReturn(false); - //refresh()->fetch + // refresh()->fetch FetchCommand fetchCommand = mock(FetchCommand.class); FetchResult fetchResult = mock(FetchResult.class); when(git.fetch()).thenReturn(fetchCommand); when(fetchCommand.setRemote(anyString())).thenReturn(fetchCommand); when(fetchCommand.call()).thenReturn(fetchResult); - when(fetchResult.getTrackingRefUpdates()).thenReturn(Collections.EMPTY_LIST); + when(fetchResult.getTrackingRefUpdates()).thenReturn(Collections.emptyList()); - //refresh()->checkout + // refresh()->checkout CheckoutCommand checkoutCommand = mock(CheckoutCommand.class); - //refresh()->checkout->containsBranch + // refresh()->checkout->containsBranch ListBranchCommand listBranchCommand = mock(ListBranchCommand.class); when(git.checkout()).thenReturn(checkoutCommand); when(git.branchList()).thenReturn(listBranchCommand); @@ -497,29 +490,36 @@ public class JGitEnvironmentRepositoryTests { when(ref.getName()).thenReturn("/master"); when(listBranchCommand.call()).thenReturn(refs); - //refresh()->merge + // refresh()->merge MergeCommand mergeCommand = mock(MergeCommand.class); when(git.merge()).thenReturn(mergeCommand); - when(mergeCommand.call()).thenThrow(new NotMergedException()); //here is our exception we are testing + when(mergeCommand.call()).thenThrow(new NotMergedException()); // here + // is + // our + // exception + // we + // are + // testing - //refresh()->hardReset + // refresh()->hardReset ResetCommand resetCommand = mock(ResetCommand.class); when(git.reset()).thenReturn(resetCommand); when(resetCommand.call()).thenReturn(ref); - //refresh()->return git.getRepository().getRef("HEAD").getObjectId().getName(); + // refresh()->return + // git.getRepository().getRef("HEAD").getObjectId().getName(); Ref headRef = mock(Ref.class); - when(repository.getRef(anyString())).thenReturn(headRef); + when(repository.findRef(anyString())).thenReturn(headRef); - ObjectId newObjectId = ObjectId.fromRaw(new int[]{1,2,3,4,5}); + ObjectId newObjectId = ObjectId.fromRaw(new int[] { 1, 2, 3, 4, 5 }); when(headRef.getObjectId()).thenReturn(newObjectId); SearchPathLocator.Locations locations = this.repository.getLocations("bar", "staging", "master"); - assertEquals(locations.getVersion(),newObjectId.getName()); + assertEquals(locations.getVersion(), newObjectId.getName()); } - + @Test - public void shouldDeleteBaseDirWhenCloneFails() throws Exception { + public void shouldDeleteBaseDirWhenCloneFails() throws Exception { Git mockGit = mock(Git.class); CloneCommand mockCloneCommand = mock(CloneCommand.class); @@ -527,19 +527,17 @@ public class JGitEnvironmentRepositoryTests { when(mockCloneCommand.setDirectory(any(File.class))).thenReturn(mockCloneCommand); when(mockCloneCommand.call()).thenThrow(new TransportException("failed to clone")); - JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository( - this.environment); + JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository(this.environment); envRepository.setGitFactory(new MockGitFactory(mockGit, mockCloneCommand)); envRepository.setUri("http://somegitserver/somegitrepo"); envRepository.setBasedir(this.basedir); - + try { envRepository.findOne("bar", "staging", "master"); - } - catch (Exception ex) { + } catch (Exception ex) { // expected - ignore } - + assertFalse("baseDir should be deleted when clone fails", this.basedir.exists()); } @@ -592,13 +590,14 @@ public class JGitEnvironmentRepositoryTests { CredentialsProvider provider = mockCloneCommand.getCredentialsProvider(); assertFalse(provider.isInteractive()); - CredentialItem.StringType stringCredential = new CredentialItem.StringType(PassphraseCredentialsProvider.PROMPT, true); + CredentialItem.StringType stringCredential = new CredentialItem.StringType(PassphraseCredentialsProvider.PROMPT, + true); assertTrue(provider.supports(stringCredential)); provider.get(new URIish(), stringCredential); assertEquals(stringCredential.getValue(), passphrase); } - + @Test public void gitCredentialsProviderFactoryCreatesPassphraseProvider() throws Exception { final String passphrase = "mypassphrase"; @@ -620,7 +619,8 @@ public class JGitEnvironmentRepositoryTests { CredentialsProvider provider = mockCloneCommand.getCredentialsProvider(); assertFalse(provider.isInteractive()); - CredentialItem.StringType stringCredential = new CredentialItem.StringType(PassphraseCredentialsProvider.PROMPT, true); + CredentialItem.StringType stringCredential = new CredentialItem.StringType(PassphraseCredentialsProvider.PROMPT, + true); assertTrue(provider.supports(stringCredential)); provider.get(new URIish(), stringCredential); @@ -640,8 +640,8 @@ public class JGitEnvironmentRepositoryTests { envRepository.setGitFactory(new MockGitFactory(mockGit, mockCloneCommand)); envRepository.setUri("git+ssh://git@somegitserver/somegitrepo"); envRepository.setBasedir(new File("./mybasedir")); - envRepository.setGitCredentialsProvider(credentialsFactory.createFor( - envRepository.getUri(), username, password, null)); + envRepository.setGitCredentialsProvider( + credentialsFactory.createFor(envRepository.getUri(), username, password, null)); envRepository.setCloneOnStart(true); envRepository.afterPropertiesSet(); @@ -665,12 +665,11 @@ public class JGitEnvironmentRepositoryTests { Git mockGit = mock(Git.class); MockCloneCommand mockCloneCommand = new MockCloneCommand(mockGit); final String awsUri = "https://git-codecommit.us-east-1.amazonaws.com/v1/repos/test"; - + JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository(this.environment); envRepository.setGitFactory(new MockGitFactory(mockGit, mockCloneCommand)); envRepository.setUri(awsUri); - envRepository.setGitCredentialsProvider(credentialsFactory.createFor( - envRepository.getUri(), null, null, null)); + envRepository.setGitCredentialsProvider(credentialsFactory.createFor(envRepository.getUri(), null, null, null)); envRepository.setCloneOnStart(true); envRepository.afterPropertiesSet(); @@ -693,14 +692,17 @@ public class JGitEnvironmentRepositoryTests { } catch (Exception e) { final OpenSshConfig.Host hc = OpenSshConfig.get(FS.detect()).lookup("github.com"); JschConfigSessionFactory factory = (JschConfigSessionFactory) SshSessionFactory.getInstance(); - // There's no public method that can be used to inspect the ssh configuration, so we'll reflect - // the configure method to allow us to check that the config property is set as expected. - Method configure = factory.getClass().getDeclaredMethod("configure", OpenSshConfig.Host.class, Session.class ); + // There's no public method that can be used to inspect the ssh + // configuration, so we'll reflect + // the configure method to allow us to check that the config + // property is set as expected. + Method configure = factory.getClass().getDeclaredMethod("configure", OpenSshConfig.Host.class, + Session.class); configure.setAccessible(true); Session session = mock(Session.class); ArgumentCaptor keyCaptor = ArgumentCaptor.forClass(String.class); ArgumentCaptor valueCaptor = ArgumentCaptor.forClass(String.class); - configure.invoke(factory, hc, session ); + configure.invoke(factory, hc, session); verify(session).setConfig(keyCaptor.capture(), valueCaptor.capture()); configure.setAccessible(false); assertTrue("yes".equals(valueCaptor.getValue())); @@ -710,7 +712,7 @@ public class JGitEnvironmentRepositoryTests { @Test public void shouldPrintStacktraceIfDebugEnabled() throws Exception { final Log mockLogger = mock(Log.class); - JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository(this.environment){ + JGitEnvironmentRepository envRepository = new JGitEnvironmentRepository(this.environment) { @Override public void afterPropertiesSet() throws Exception { this.logger = mockLogger; @@ -774,13 +776,12 @@ public class JGitEnvironmentRepositoryTests { } } - class MockGitFactory extends JGitEnvironmentRepository.JGitFactory { private Git mockGit; private CloneCommand mockCloneCommand; - public MockGitFactory (Git mockGit, CloneCommand mockCloneCommand) { + public MockGitFactory(Git mockGit, CloneCommand mockCloneCommand) { this.mockGit = mockGit; this.mockCloneCommand = mockCloneCommand; }