@Test public void should_update_sagan_for_milestone() throws Exception { this.saganUpdater.updateSagan("master", version("1.0.0.M1"), version("1.0.0.M1")); BDDMockito.then(this.saganClient).should().updateRelease(BDDMockito.eq("foo"), BDDMockito.argThat(withReleaseUpdate("1.0.0.M1", "http://cloud.spring.io/spring-cloud-static/foo/{version}/", "PRERELEASE"))); }
@Before public void setUpTest() throws Exception { // Mockito has a very convenient way to inject mocks by using the @Mock annotation. To // inject the mocks in the test the initMocks method needs to be called. MockitoAnnotations.initMocks(this); mContext = mock(Activity.class); mMockSharedPreferences = mock(SharedPreferences.class); resource = mock(Resources.class); when(mContext.getSharedPreferences(anyString(), anyInt())).thenReturn(mMockSharedPreferences); when(mMockSharedPreferences.getString(anyString(), anyString())).thenReturn("foobar"); when(mContext.getResources()).thenReturn(resource); when(resource.getBoolean(anyInt())).thenReturn(true); liSDKManager = LiSDKManager.init(mContext, TestHelper.getTestAppCredentials()); liRestv2Client = PowerMockito.mock(LiRestv2Client.class); PowerMockito.mockStatic(LiRestv2Client.class); BDDMockito.given(LiRestv2Client.getInstance()).willReturn(liRestv2Client); }
@Before public void setUp() throws Exception { mContext = Mockito.mock(Activity.class); mMockSharedPreferences = Mockito.mock(SharedPreferences.class); resource = Mockito.mock(Resources.class); when(resource.getBoolean(anyInt())).thenReturn(true); when(mContext.getSharedPreferences(anyString(), anyInt())).thenReturn(mMockSharedPreferences); when(mMockSharedPreferences.getString(anyString(), anyString())).thenReturn("foobar"); when(mContext.getResources()).thenReturn(resource); JsonObject jsonObject = new Gson().fromJson(defaultSettings, JsonObject.class); liSDKManager = LiSDKManager.init(mContext, TestHelper.getTestAppCredentials()); liRestv2Client = mock(LiRestv2Client.class); // when(liSDKManager.getTenant()).thenReturn("test"); PowerMockito.mockStatic(LiRestv2Client.class); BDDMockito.given(LiRestv2Client.getInstance()).willReturn(liRestv2Client); liClient = new LiBaseGetClient(mContext, LI_ARTICLES_CLIENT_BASE_LIQL, LI_ARTICLES_CLIENT_TYPE, LI_ARTICLES_QUERYSETTINGS_TYPE, LiMessage.class); }
@Before public void setUp() throws Exception, LiRestResponseException { mContext = Mockito.mock(Activity.class); mMockSharedPreferences = Mockito.mock(SharedPreferences.class); resource = Mockito.mock(Resources.class); when(resource.getBoolean(anyInt())).thenReturn(true); when(mContext.getSharedPreferences(anyString(), anyInt())).thenReturn(mMockSharedPreferences); when(mMockSharedPreferences.getString(anyString(), anyString())).thenReturn("foobar"); when(mContext.getResources()).thenReturn(resource); liSDKManager = LiSDKManager.init(mContext, TestHelper.getTestAppCredentials()); liRestv2Client = mock(LiRestv2Client.class); MockitoAnnotations.initMocks(this); // when(liSDKManager.getTenant()).thenReturn("test"); liClientManager = mock(LiClientManager.class); PowerMockito.mockStatic(LiRestv2Client.class); BDDMockito.given(LiRestv2Client.getInstance()).willReturn(liRestv2Client); PowerMockito.mockStatic(LiClientManager.class); }
@Before public void setUpTest() throws Exception { MockitoAnnotations.initMocks(this); mContext = mock(Activity.class); mMockSharedPreferences = mock(SharedPreferences.class); resource = mock(Resources.class); when(resource.getBoolean(anyInt())).thenReturn(true); when(mContext.getSharedPreferences(anyString(), anyInt())).thenReturn(mMockSharedPreferences); when(mMockSharedPreferences.getString(anyString(), anyString())).thenReturn("foobar"); when(mContext.getResources()).thenReturn(resource); JsonObject jsonObject = new Gson().fromJson(defaultSettings, JsonObject.class); liDefaultQueryHelper = mock(LiDefaultQueryHelper.class); when(liDefaultQueryHelper.getDefaultSetting()).thenReturn(jsonObject); PowerMockito.mockStatic(LiDefaultQueryHelper.class); when(LiDefaultQueryHelper.initHelper(mContext)).thenReturn(liDefaultQueryHelper); BDDMockito.given(LiDefaultQueryHelper.getInstance()).willReturn(liDefaultQueryHelper); liSDKManager = LiSDKManager.init(mContext, TestHelper.getTestAppCredentials()); }
@Test @WithMockUser public void testCadastrarLancamento() throws Exception { Lancamento lancamento = obterDadosLancamento(); BDDMockito.given(this.funcionarioService.buscarPorId(Mockito.anyLong())).willReturn(Optional.of(new Funcionario())); BDDMockito.given(this.lancamentoService.persistir(Mockito.any(Lancamento.class))).willReturn(lancamento); mvc.perform(MockMvcRequestBuilders.post(URL_BASE) .content(this.obterJsonRequisicaoPost()) .contentType(MediaType.APPLICATION_JSON) .accept(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(jsonPath("$.data.id").value(ID_LANCAMENTO)) .andExpect(jsonPath("$.data.tipo").value(TIPO)) .andExpect(jsonPath("$.data.data").value(this.dateFormat.format(DATA))) .andExpect(jsonPath("$.data.funcionarioId").value(ID_FUNCIONARIO)) .andExpect(jsonPath("$.errors").isEmpty()); }
@Test public void testChannelRead0_debugOnResponse() { Mockito.when(LOGGER.isDebugEnabled()).thenReturn(true); Mockito.when(response.getStatus()).thenReturn(HttpResponseStatus.OK); Mockito.when(response.getProtocolVersion()).thenReturn(HttpVersion.HTTP_1_1); Mockito.when(headers.isEmpty()).thenReturn(false); Set<String> headersSet = new HashSet<>(); headersSet.add("no-cache"); Mockito.when(headers.names()).thenReturn(headersSet); List<String> noCacheValues = new ArrayList<>(); noCacheValues.add("private"); Mockito.when(headers.getAll("no-cache")).thenReturn(noCacheValues); PowerMockito.mockStatic(HttpHeaders.class); BDDMockito.given(HttpHeaders.isTransferEncodingChunked(response)).willReturn(true); handler.channelRead0(ctx, response); Mockito.verify(LOGGER, Mockito.times(1)).debug("STATUS: " + HttpResponseStatus.OK); Mockito.verify(LOGGER, Mockito.times(1)).debug("VERSION: " + HttpVersion.HTTP_1_1); Mockito.verify(LOGGER, Mockito.times(1)).debug("HEADER: no-cache = private"); Mockito.verify(LOGGER, Mockito.times(1)).debug("CHUNKED CONTENT {"); BDDMockito.given(HttpHeaders.isTransferEncodingChunked(response)).willReturn(false); handler.channelRead0(ctx, response); Mockito.verify(LOGGER, Mockito.times(1)).debug("CONTENT {"); }
@Test public void testLogger() throws Exception { String helloWorld = "Hello world!"; BDDMockito.given(Log.d(Logger.TAG,helloWorld)).willReturn(Log.DEBUG); BDDMockito.given(Log.v(Logger.TAG,helloWorld)).willReturn(Log.VERBOSE); BDDMockito.given(Log.i(Logger.TAG,helloWorld)).willReturn(Log.INFO); BDDMockito.given(Log.e(Logger.TAG,helloWorld)).willReturn(Log.ERROR); BDDMockito.given(Log.w(Logger.TAG,helloWorld)).willReturn(Log.WARN); assertEquals(Logger.d(helloWorld), Log.DEBUG); assertEquals(Logger.v(helloWorld), Log.VERBOSE); assertEquals(Logger.i(helloWorld), Log.INFO); assertEquals(Logger.e(helloWorld), Log.ERROR); assertEquals(Logger.w(helloWorld), Log.WARN); }
@Test public void testMethods() throws Exception { FraudScreeningMapper fraudScreeningMapper = new FraudScreeningMapper(jsonObject); when(jsonObject.optString("result", null)).thenReturn("bLOCked"); when(jsonObject.opt("scoring")).thenReturn("1"); when(jsonObject.optString("review", null)).thenReturn("denIEd"); BDDMockito.given(TextUtils.isDigitsOnly("1")).willReturn(true); FraudScreening compareFraudScreeningCompare = new FraudScreening(); compareFraudScreeningCompare.setScoring(1); compareFraudScreeningCompare.setResult(FraudScreening.FraudScreeningResult.FraudScreeningResultBlocked); compareFraudScreeningCompare.setReview(FraudScreening.FraudScreeningReview.FraudScreeningReviewDenied); FraudScreening fraudScreeningTest = fraudScreeningMapper.mappedObject(); assertEquals(fraudScreeningTest.getResult(), compareFraudScreeningCompare.getResult()); assertEquals(fraudScreeningTest.getReview(), compareFraudScreeningCompare.getReview()); assertEquals(fraudScreeningTest.getScoring(), compareFraudScreeningCompare.getScoring()); }
@Test public void standardApplicationContext() throws Exception { BDDMockito.<Class<?>> given(testContext.getTestClass()).willReturn(getClass()); given(testContext.getApplicationContext()).willReturn(mock(ApplicationContext.class)); listener.beforeTestClass(testContext); assertAttributeExists(); listener.prepareTestInstance(testContext); assertAttributeExists(); listener.beforeTestMethod(testContext); assertAttributeExists(); listener.afterTestMethod(testContext); assertAttributeExists(); }
@Test public void legacyWebTestCaseWithoutExistingRequestAttributes() throws Exception { BDDMockito.<Class<?>> given(testContext.getTestClass()).willReturn(LegacyWebTestCase.class); RequestContextHolder.resetRequestAttributes(); assertAttributesNotAvailable(); listener.beforeTestClass(testContext); listener.prepareTestInstance(testContext); assertAttributesNotAvailable(); verify(testContext, times(0)).setAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE, Boolean.TRUE); given(testContext.getAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE)).willReturn(null); listener.beforeTestMethod(testContext); assertAttributesNotAvailable(); verify(testContext, times(0)).setAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE, Boolean.TRUE); listener.afterTestMethod(testContext); verify(testContext, times(1)).removeAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE); assertAttributesNotAvailable(); }
@Test public void legacyWebTestCaseWithPresetRequestAttributes() throws Exception { BDDMockito.<Class<?>> given(testContext.getTestClass()).willReturn(LegacyWebTestCase.class); listener.beforeTestClass(testContext); assertAttributeExists(); listener.prepareTestInstance(testContext); assertAttributeExists(); verify(testContext, times(0)).setAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE, Boolean.TRUE); given(testContext.getAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE)).willReturn(null); listener.beforeTestMethod(testContext); assertAttributeExists(); verify(testContext, times(0)).setAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE, Boolean.TRUE); given(testContext.getAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE)).willReturn(null); listener.afterTestMethod(testContext); verify(testContext, times(1)).removeAttribute(RESET_REQUEST_CONTEXT_HOLDER_ATTRIBUTE); assertAttributeExists(); }
@Test public void testInputStreamThatFailsOnClose() throws Exception { final InputStream inputStream = PowerMockito.mock(InputStream.class); Mockito.doThrow(IOException.class).when(inputStream).close(); final int available = Mockito.doThrow(IOException.class).when(inputStream).available(); final URL url = PowerMockito.mock(URL.class); BDDMockito.given(url.openStream()).willReturn(inputStream); final URI uri = PowerMockito.mock(URI.class); BDDMockito.given(uri.toURL()).willReturn(url); try { ImportControlLoader.load(uri); //Using available to bypass 'ignored result' warning fail("exception expected " + available); } catch (CheckstyleException ex) { assertSame("Invalid exception class", IOException.class, ex.getCause().getClass()); } Mockito.verify(inputStream).close(); }
@Test public void testInputStreamFailsOnRead() throws Exception { final InputStream inputStream = PowerMockito.mock(InputStream.class); final int available = Mockito.doThrow(IOException.class).when(inputStream).available(); final URL url = PowerMockito.mock(URL.class); BDDMockito.given(url.openStream()).willReturn(inputStream); final URI uri = PowerMockito.mock(URI.class); BDDMockito.given(uri.toURL()).willReturn(url); try { ImportControlLoader.load(uri); //Using available to bypass 'ignored result' warning fail("exception expected " + available); } catch (CheckstyleException ex) { assertSame("Invalid exception class", SAXParseException.class, ex.getCause().getClass()); } }
@Test @PrepareForTest({FilterUtils.class, CommonUtils.class}) public void testExceptionOnClosing() throws Exception { final File file = temporaryFolder.newFile("existing.xml"); final InputStream inputStream = PowerMockito.mock(InputStream.class); Mockito.doThrow(IOException.class).when(inputStream).close(); final URL url = PowerMockito.mock(URL.class); BDDMockito.given(url.openStream()).willReturn(inputStream); final URI uri = PowerMockito.mock(URI.class); BDDMockito.given(uri.toURL()).willReturn(url); PowerMockito.mockStatic(CommonUtils.class); final String fileName = file.getPath(); BDDMockito.given(CommonUtils.getUriByFilename(fileName)).willReturn(uri); assertFalse("Should be false, because error on close", FilterUtils.isFileExists(fileName)); }
@Test public void testGetDeniedPermissions_whenMixPermissionsGrantedAndUngranted_returnUngrantedPermissions() { // Case 3: 2 permissions, 1 ungranted, 1 granted BDDMockito.given( PermissionChecker.checkSelfPermission( any(Context.class), eq(Manifest.permission.WRITE_EXTERNAL_STORAGE) ) ).willReturn(PackageManager.PERMISSION_DENIED); BDDMockito.given( PermissionChecker.checkSelfPermission(any(Context.class), eq(Manifest.permission.READ_SMS)) ).willReturn(PackageManager.PERMISSION_GRANTED); final String[] deniedPermissions = PermissMeUtils.getDeniedPermissions( mockContext, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_SMS ); assertNotNull(deniedPermissions); assertTrue(deniedPermissions.length == 1); assertTrue(deniedPermissions[0].equals(Manifest.permission.WRITE_EXTERNAL_STORAGE)); }
@Test public void testGetDeniedPermissions_whenAllPermissionsUngranted_returnAllPermissions() { // Case 4: 2 permissions, 2 ungranted BDDMockito.given( PermissionChecker.checkSelfPermission(any(Context.class), anyString()) ).willReturn(PackageManager.PERMISSION_DENIED); String[] deniedPermissions = PermissMeUtils.getDeniedPermissions( mockContext, Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_SMS ); assertNotNull(deniedPermissions); assertTrue(deniedPermissions.length == 2); assertTrue(deniedPermissions[0].equals(Manifest.permission.WRITE_EXTERNAL_STORAGE)); assertTrue(deniedPermissions[1].equals(Manifest.permission.READ_SMS)); }
@Test public void should_not_throw_exception_if_parent_id_is_invalid() { BDDMockito.given(this.request.getHeader(Span.TRACE_ID_NAME)) .willReturn(String.valueOf(new Random().nextLong())); BDDMockito.given(this.request.getHeader(Span.SPAN_ID_NAME)) .willReturn(String.valueOf(new Random().nextLong())); BDDMockito.given(this.request.getHeader(Span.PARENT_ID_NAME)) .willReturn("invalid"); try { this.extractor.joinTrace(this.request); fail("should throw an exception"); } catch (IllegalArgumentException e) { then(e).hasMessageContaining("Malformed id"); } }
@Test public void should_not_create_a_span_when_current_thread_should_be_ignored() throws ExecutionException, InterruptedException { String threadNameToIgnore = "^MyCustomThread.*$"; RxJavaPlugins.getInstance().registerSchedulersHook(new MyRxJavaSchedulersHook()); SleuthRxJavaSchedulersHook schedulersHook = new SleuthRxJavaSchedulersHook( this.tracer, this.traceKeys, Collections.singletonList(threadNameToIgnore)); Future<Void> hello = executorService().submit((Callable<Void>) () -> { Action0 action = schedulersHook.onSchedule(() -> { caller = new StringBuilder("hello"); }); action.call(); return null; }); hello.get(); BDDMockito.then(this.tracer).should(never()).createSpan(anyString()); BDDMockito.then(this.tracer).should(never()).continueSpan(any()); }
@Test public void should_set_runnable_name_to_annotated_value() throws ExecutionException, InterruptedException { ExecutorService executorService = Executors.newSingleThreadExecutor(); SpanNamer spanNamer = new DefaultSpanNamer(); Tracer tracer = Mockito.mock(Tracer.class); // tag::span_name_annotated_runnable_execution[] Runnable runnable = new TraceRunnable(tracer, spanNamer, new TaxCountingRunnable()); Future<?> future = executorService.submit(runnable); // ... some additional logic ... future.get(); // end::span_name_annotated_runnable_execution[] BDDMockito.then(tracer).should().createSpan(BDDMockito.eq("calculateTax"), BDDMockito.any(Span.class)); }
@Test public void should_set_runnable_name_to_to_string_value() throws ExecutionException, InterruptedException { ExecutorService executorService = Executors.newSingleThreadExecutor(); SpanNamer spanNamer = new DefaultSpanNamer(); Tracer tracer = Mockito.mock(Tracer.class); // tag::span_name_to_string_runnable_execution[] Runnable runnable = new TraceRunnable(tracer, spanNamer, new Runnable() { @Override public void run() { // perform logic } @Override public String toString() { return "calculateTax"; } }); Future<?> future = executorService.submit(runnable); // ... some additional logic ... future.get(); // end::span_name_to_string_runnable_execution[] BDDMockito.then(tracer).should().createSpan(BDDMockito.eq("calculateTax"), BDDMockito.any(Span.class)); executorService.shutdown(); }
@Test public void shouldUseCustomConstraintViolationExceptionMapper() { Throwable thrown = catchThrowable(() -> customValidatedService.requireNonNull(null)); then(thrown).isInstanceOf(RuntimeException.class); BDDMockito.then(mockMapper).should().apply(any()); }
private String containsWarnMsgAboutEmptyVersion() { return BDDMockito.argThat(new TypeSafeMatcher<String>() { @Override protected boolean matchesSafely(String item) { return item.contains("is empty. Will not set it"); } @Override public void describeTo(Description description) { } }); }
@Test public void should_update_sagan_for_rc() throws Exception { this.saganUpdater.updateSagan("master", version("1.0.0.RC1"), version("1.0.0.RC1")); BDDMockito.then(this.saganClient).should().updateRelease(BDDMockito.eq("foo"), BDDMockito.argThat(withReleaseUpdate("1.0.0.RC1", "http://cloud.spring.io/spring-cloud-static/foo/{version}/", "PRERELEASE"))); }
@Test public void should_update_sagan_from_master() throws Exception { ProjectVersion projectVersion = version("1.0.0.BUILD-SNAPSHOT"); this.saganUpdater.updateSagan("master", projectVersion, projectVersion); BDDMockito.then(this.saganClient).should().updateRelease(BDDMockito.eq("foo"), BDDMockito.argThat(withReleaseUpdate("1.0.0.BUILD-SNAPSHOT", "http://cloud.spring.io/foo/foo.html", "SNAPSHOT"))); }
@Test public void should_update_sagan_from_release_version() throws Exception { ProjectVersion projectVersion = version("1.0.0.RELEASE"); this.saganUpdater.updateSagan("master", projectVersion, projectVersion); BDDMockito.then(this.saganClient).should().updateRelease(BDDMockito.eq("foo"), BDDMockito.argThat(withReleaseUpdate("1.0.0.RELEASE", "http://cloud.spring.io/spring-cloud-static/foo/{version}/", "GENERAL_AVAILABILITY"))); BDDMockito.then(this.saganClient).should().deleteRelease("foo", "1.0.0.BUILD-SNAPSHOT"); BDDMockito.then(this.saganClient).should().updateRelease(BDDMockito.eq("foo"), BDDMockito.argThat(withReleaseUpdate("1.0.1.BUILD-SNAPSHOT", "http://cloud.spring.io/foo/foo.html", "SNAPSHOT"))); }
@Test public void should_update_sagan_from_non_master() throws Exception { ProjectVersion projectVersion = version("1.1.0.BUILD-SNAPSHOT"); this.saganUpdater.updateSagan("1.1.x", projectVersion, projectVersion); BDDMockito.then(this.saganClient).should().updateRelease(BDDMockito.eq("foo"), BDDMockito.argThat(withReleaseUpdate("1.1.0.BUILD-SNAPSHOT", "http://cloud.spring.io/foo/1.1.x/", "SNAPSHOT"))); }
@Test public void should_perform_a_release_of_consul() throws Exception { File origin = GitTestUtils.clonedProject(this.tmp.newFolder(), this.springCloudConsulProject); pomVersionIsEqualTo(origin, "1.2.0.BUILD-SNAPSHOT"); pomParentVersionIsEqualTo(origin, "1.2.0.BUILD-SNAPSHOT"); File project = GitTestUtils.clonedProject(this.tmp.newFolder(), tmpFile("spring-cloud-consul")); GitTestUtils.setOriginOnProjectToTmp(origin, project); SpringReleaser releaser = releaser(project, "vCamden.SR5", "1.1.2.RELEASE"); releaser.release(); Iterable<RevCommit> commits = listOfCommits(project); Iterator<RevCommit> iterator = commits.iterator(); tagIsPresentInOrigin(origin, "v1.1.2.RELEASE"); commitIsPresent(iterator, "Bumping versions to 1.2.1.BUILD-SNAPSHOT after release"); commitIsPresent(iterator, "Going back to snapshots"); commitIsPresent(iterator, "Update SNAPSHOT to 1.1.2.RELEASE"); pomVersionIsEqualTo(project, "1.2.1.BUILD-SNAPSHOT"); pomParentVersionIsEqualTo(project, "1.2.1.BUILD-SNAPSHOT"); then(this.gitHandler.closedMilestones).isTrue(); then(emailTemplate()).exists(); then(emailTemplateContents()) .contains("Spring Cloud Camden.SR5 available") .contains("Spring Cloud Camden SR5 Train release"); then(blogTemplate()).exists(); then(blogTemplateContents()) .contains("I am pleased to announce that the Service Release 5 (SR5)"); then(releaseNotesTemplate()).exists(); then(releaseNotesTemplateContents()) .contains("Camden.SR5") .contains("- Spring Cloud Config `1.2.2.RELEASE` ([issues](http://foo.bar.com/1.2.2.RELEASE))") .contains("- Spring Cloud Aws `1.1.3.RELEASE` ([issues](http://foo.bar.com/1.1.3.RELEASE))"); // once for updating GA // second time to update SNAPSHOT BDDMockito.then(this.saganClient).should(BDDMockito.times(2)).updateRelease(BDDMockito.eq("spring-cloud-consul"), BDDMockito.anyList()); BDDMockito.then(this.saganClient).should().deleteRelease("spring-cloud-consul", "1.1.2.BUILD-SNAPSHOT"); }
@Test public void should_perform_a_release_of_consul_rc1() throws Exception { File origin = GitTestUtils.clonedProject(this.tmp.newFolder(), this.springCloudConsulProject); pomVersionIsEqualTo(origin, "1.2.0.BUILD-SNAPSHOT"); pomParentVersionIsEqualTo(origin, "1.2.0.BUILD-SNAPSHOT"); File project = GitTestUtils.clonedProject(this.tmp.newFolder(), tmpFile("spring-cloud-consul")); GitTestUtils.setOriginOnProjectToTmp(origin, project); SpringReleaser releaser = releaser(project, "Dalston.RC1", "1.2.0.RC1"); releaser.release(); Iterable<RevCommit> commits = listOfCommits(project); tagIsPresentInOrigin(origin, "v1.2.0.RC1"); commitIsNotPresent(commits, "Bumping versions to 1.2.1.BUILD-SNAPSHOT after release"); Iterator<RevCommit> iterator = listOfCommits(project).iterator(); commitIsPresent(iterator, "Going back to snapshots"); commitIsPresent(iterator, "Update SNAPSHOT to 1.2.0.RC1"); pomVersionIsEqualTo(project, "1.2.0.BUILD-SNAPSHOT"); pomParentVersionIsEqualTo(project, "1.2.0.BUILD-SNAPSHOT"); then(this.gitHandler.closedMilestones).isTrue(); then(emailTemplate()).exists(); then(emailTemplateContents()) .contains("Spring Cloud Dalston.RC1 available") .contains("Spring Cloud Dalston RC1 Train release"); then(blogTemplate()).exists(); then(blogTemplateContents()) .contains("I am pleased to announce that the Release Candidate 1 (RC1)"); then(tweetTemplate()).exists(); then(tweetTemplateContents()) .contains("The Dalston.RC1 version of @springcloud has been released!"); then(releaseNotesTemplate()).exists(); then(releaseNotesTemplateContents()) .contains("Dalston.RC1") .contains("- Spring Cloud Build `1.3.1.RELEASE` ([issues](http://foo.bar.com/1.3.1.RELEASE))") .contains("- Spring Cloud Bus `1.3.0.M1` ([issues](http://foo.bar.com/1.3.0.M1))"); BDDMockito.then(this.saganClient).should().updateRelease(BDDMockito.eq("spring-cloud-consul"), BDDMockito.anyList()); }
@Test public void should_generate_templates_only() throws Exception { File origin = GitTestUtils.clonedProject(this.tmp.newFolder(), this.springCloudConsulProject); pomVersionIsEqualTo(origin, "1.2.0.BUILD-SNAPSHOT"); pomParentVersionIsEqualTo(origin, "1.2.0.BUILD-SNAPSHOT"); File project = GitTestUtils.clonedProject(this.tmp.newFolder(), tmpFile("spring-cloud-consul")); GitTestUtils.setOriginOnProjectToTmp(origin, project); SpringReleaser releaser = templateOnlyReleaser(project, "Dalston.RC1", "1.2.0.RC1"); releaser.release(); then(this.gitHandler.closedMilestones).isFalse(); then(emailTemplate()).exists(); then(emailTemplateContents()) .contains("Spring Cloud Dalston.RC1 available") .contains("Spring Cloud Dalston RC1 Train release"); then(blogTemplate()).exists(); then(blogTemplateContents()) .contains("I am pleased to announce that the Release Candidate 1 (RC1)"); then(tweetTemplate()).exists(); then(tweetTemplateContents()) .contains("The Dalston.RC1 version of @springcloud has been released!"); then(releaseNotesTemplate()).exists(); then(releaseNotesTemplateContents()) .contains("Dalston.RC1") .contains("- Spring Cloud Build `1.3.1.RELEASE` ([issues](http://foo.bar.com/1.3.1.RELEASE))") .contains("- Spring Cloud Bus `1.3.0.M1` ([issues](http://foo.bar.com/1.3.0.M1)"); BDDMockito.then(this.saganClient).should(BDDMockito.never()).updateRelease( BDDMockito.anyString(), BDDMockito.anyList()); }
@Before public void setUp() throws LiRestResponseException { mContext = Mockito.mock(Activity.class); liRestv2Client = mock(LiRestv2Client.class); PowerMockito.mockStatic(LiRestv2Client.class); BDDMockito.given(LiRestv2Client.getInstance()).willReturn(liRestv2Client); liClient = new LiBasePostClient(mContext, BASE_PATH); PowerMockito.verifyStatic(); }
@Before public void setUp() throws LiRestResponseException { mContext = Mockito.mock(Activity.class); liRestv2Client = mock(LiRestv2Client.class); PowerMockito.mockStatic(LiRestv2Client.class); BDDMockito.given(LiRestv2Client.getInstance()).willReturn(liRestv2Client); liClient = new LiBasePutClient(mContext, BASE_PATH); PowerMockito.verifyStatic(); }
@Test public void testGetGsonForNull() throws LiRestResponseException { LiRestv2Client liRestv2Client = null; PowerMockito.mockStatic(LiRestv2Client.class); BDDMockito.given(LiRestv2Client.getInstance()).willReturn(liRestv2Client); LiBaseClient liClient = new LiBaseGetClient(mContext, LI_ARTICLES_CLIENT_BASE_LIQL, LI_ARTICLES_CLIENT_TYPE, LI_ARTICLES_QUERYSETTINGS_TYPE, LiMessage.class); Assert.assertEquals(null, liClient.getGson()); PowerMockito.verifyStatic(); }
@Before public void setUp() throws LiRestResponseException { mContext = Mockito.mock(Activity.class); liRestv2Client = mock(LiRestv2Client.class); PowerMockito.mockStatic(LiRestv2Client.class); BDDMockito.given(LiRestv2Client.getInstance()).willReturn(liRestv2Client); liClient = new LiBaseDeleteClient(mContext, BASE_PATH); PowerMockito.verifyStatic(); }
@Test public void testGetCurrentTimeMillis() { PowerMockito.mockStatic(System.class); BDDMockito.given(System.currentTimeMillis()).willReturn(currentTime); long output = LiSystemClock.INSTANCE.getCurrentTimeMillis(); PowerMockito.verifyStatic(); Assert.assertEquals(1L, output); }
@Test public void testValidateResponse() throws Exception { context = Mockito.mock(Activity.class); PowerMockito.mockStatic(LiClientManager.class); LiClientManager liClientManager = PowerMockito.mock(LiClientManager.class); PowerMockito.mockStatic(SSLContext.class); SSLContext sslContext = PowerMockito.mock(SSLContext.class); when(sslContext.getInstance("SSL")).thenReturn(sslContext); Mockito.doNothing().when(sslContext).init(isA(KeyManager[].class), isA(TrustManager[].class), isA(SecureRandom.class)); SSLSocketFactory socketFactory = mock(SSLSocketFactory.class); when(sslContext.getSocketFactory()).thenReturn(socketFactory); PowerMockito.mockStatic(Platform.class); Platform platform = PowerMockito.mock(Platform.class); X509TrustManager trustManager = mock(X509TrustManager.class); when(platform.trustManager(socketFactory)).thenReturn(trustManager); BDDMockito.given(Platform.get()).willReturn(platform); BDDMockito.given(SSLContext.getInstance("SSL")).willReturn(sslContext); LiRestv2Client liRestv2Client = LiRestv2Client.getInstance(); final LiBaseResponse liBaseResponse = mock(LiBaseResponse.class); when(liBaseResponse.getHttpCode()).thenReturn(200); LiRestv2Client liRestv2ClientSpy = spy(LiRestv2Client.class); doReturn(liBaseResponse).when(liRestv2ClientSpy).processSync(isA(LiBaseRestRequest.class)); LiRestV2Request liBaseRestRequest = new LiRestV2Request(context, liql, "message"); liBaseRestRequest.addQueryParam("test"); LiBaseResponse liBaseResponse1 = liRestv2ClientSpy.processSync(liBaseRestRequest); Assert.assertEquals(200, liBaseResponse1.getHttpCode()); PowerMockito.verifyStatic(); }
@Before public void setUp() throws Exception { BDDMockito .given(this.lancamentoRepository.findByFuncionarioId(Mockito.anyLong(), Mockito.any(PageRequest.class))) .willReturn(new PageImpl<Lancamento>(new ArrayList<Lancamento>())); BDDMockito.given(this.lancamentoRepository.findOne(Mockito.anyLong())).willReturn(new Lancamento()); BDDMockito.given(this.lancamentoRepository.save(Mockito.any(Lancamento.class))).willReturn(new Lancamento()); }
@Before public void setUp() throws Exception { BDDMockito.given(this.funcionarioRepository.save(Mockito.any(Funcionario.class))).willReturn(new Funcionario()); BDDMockito.given(this.funcionarioRepository.findOne(Mockito.anyLong())).willReturn(new Funcionario()); BDDMockito.given(this.funcionarioRepository.findByEmail(Mockito.anyString())).willReturn(new Funcionario()); BDDMockito.given(this.funcionarioRepository.findByCpf(Mockito.anyString())).willReturn(new Funcionario()); }
@Test @WithMockUser public void testBuscarEmpresaCnpjInvalido() throws Exception { BDDMockito.given(this.empresaService.buscarPorCnpj(Mockito.anyString())).willReturn(Optional.empty()); mvc.perform(MockMvcRequestBuilders.get(BUSCAR_EMPRESA_CNPJ_URL + CNPJ).accept(MediaType.APPLICATION_JSON)) .andExpect(status().isBadRequest()) .andExpect(jsonPath("$.errors").value("Empresa não encontrada para o CNPJ " + CNPJ)); }
@Test @WithMockUser public void testBuscarEmpresaCnpjValido() throws Exception { BDDMockito.given(this.empresaService.buscarPorCnpj(Mockito.anyString())) .willReturn(Optional.of(this.obterDadosEmpresa())); mvc.perform(MockMvcRequestBuilders.get(BUSCAR_EMPRESA_CNPJ_URL + CNPJ) .accept(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()) .andExpect(jsonPath("$.data.id").value(ID)) .andExpect(jsonPath("$.data.razaoSocial", equalTo(RAZAO_SOCIAL))) .andExpect(jsonPath("$.data.cnpj", equalTo(CNPJ))) .andExpect(jsonPath("$.errors").isEmpty()); }