From c4498d1bae442247f2b2b96d8f4c788052c13655 Mon Sep 17 00:00:00 2001 From: Shubham Naik Date: Sat, 5 Oct 2019 13:18:50 +0530 Subject: [PATCH] Kotlin Migration: Convert tests to Kotlin part 1 - Converted test classes `AwesomeValidationTest`, `ValidationHolderTest`, `ValidationStyleTest` to Kotlin. - Ensured all the tests are running and are passed successfully. - Added Kotlin version `1.3.50` to the project. --- build.gradle | 2 + library/build.gradle | 6 +- .../AwesomeValidationTest.java | 368 ----------------- .../AwesomeValidationTest.kt | 375 ++++++++++++++++++ .../ValidationHolderTest.java | 342 ---------------- .../awesomevalidation/ValidationHolderTest.kt | 334 ++++++++++++++++ .../ValidationStyleTest.java | 33 -- .../awesomevalidation/ValidationStyleTest.kt | 36 ++ 8 files changed, 752 insertions(+), 744 deletions(-) delete mode 100644 library/src/test/java/com/basgeekball/awesomevalidation/AwesomeValidationTest.java create mode 100644 library/src/test/java/com/basgeekball/awesomevalidation/AwesomeValidationTest.kt delete mode 100644 library/src/test/java/com/basgeekball/awesomevalidation/ValidationHolderTest.java create mode 100644 library/src/test/java/com/basgeekball/awesomevalidation/ValidationHolderTest.kt delete mode 100644 library/src/test/java/com/basgeekball/awesomevalidation/ValidationStyleTest.java create mode 100644 library/src/test/java/com/basgeekball/awesomevalidation/ValidationStyleTest.kt diff --git a/build.gradle b/build.gradle index cd94137..a6694a4 100644 --- a/build.gradle +++ b/build.gradle @@ -1,6 +1,7 @@ // Top-level build file where you can add configuration options common to all sub-projects/modules. buildscript { + ext.kotlinVersion = '1.3.50' repositories { jcenter() google() @@ -8,6 +9,7 @@ buildscript { dependencies { classpath 'com.android.tools.build:gradle:3.4.2' classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:0.8.6" + classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion" } } diff --git a/library/build.gradle b/library/build.gradle index dc7b285..c04490b 100644 --- a/library/build.gradle +++ b/library/build.gradle @@ -1,4 +1,5 @@ apply plugin: "com.android.library" +apply plugin: "kotlin-android" apply plugin: "com.getkeepsafe.dexcount" apply from: "gradle/script/coverage.gradle" @@ -48,6 +49,7 @@ ext { guavaVersion = "26.0-android" junitVersion = "4.12" mockitoVersion = "2.21.0" + mockitokotlinVersion = "2.2.0" easymockVersion = "3.6" powermockVersion = "2.0.0-beta.5" } @@ -55,6 +57,7 @@ ext { dependencies { implementation "com.android.support:design:${rootProject.ext.androidSupportLibVersion}" implementation "com.android.support.constraint:constraint-layout:1.1.3" + implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${rootProject.ext.kotlinVersion}" api("com.google.guava:guava:${guavaVersion}") { exclude module: "jsr305" } @@ -64,6 +67,7 @@ dependencies { testImplementation "org.powermock:powermock-module-junit4:${powermockVersion}" testImplementation "org.powermock:powermock-api-mockito2:${powermockVersion}" testImplementation "org.powermock:powermock-api-easymock:${powermockVersion}" + testImplementation "com.nhaarman.mockitokotlin2:mockito-kotlin:$mockitokotlinVersion" } configurations.all { @@ -72,4 +76,4 @@ configurations.all { } } -apply from: "$rootProject.projectDir/publish.gradle" +apply from: "$rootProject.projectDir/publish.gradle" \ No newline at end of file diff --git a/library/src/test/java/com/basgeekball/awesomevalidation/AwesomeValidationTest.java b/library/src/test/java/com/basgeekball/awesomevalidation/AwesomeValidationTest.java deleted file mode 100644 index 9137a3b..0000000 --- a/library/src/test/java/com/basgeekball/awesomevalidation/AwesomeValidationTest.java +++ /dev/null @@ -1,368 +0,0 @@ -package com.basgeekball.awesomevalidation; - -import android.app.Activity; -import android.content.Context; -import android.support.design.widget.TextInputLayout; -import android.support.v4.content.ContextCompat; -import android.view.View; -import android.widget.EditText; - -import com.basgeekball.awesomevalidation.model.NumericRange; -import com.basgeekball.awesomevalidation.utility.custom.CustomErrorReset; -import com.basgeekball.awesomevalidation.utility.custom.CustomValidation; -import com.basgeekball.awesomevalidation.utility.custom.CustomValidationCallback; -import com.basgeekball.awesomevalidation.utility.custom.SimpleCustomValidation; -import com.basgeekball.awesomevalidation.validators.BasicValidator; -import com.basgeekball.awesomevalidation.validators.ColorationValidator; -import com.basgeekball.awesomevalidation.validators.TextInputLayoutValidator; -import com.basgeekball.awesomevalidation.validators.UnderlabelValidator; -import com.google.common.collect.Range; - -import junit.framework.TestCase; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.powermock.api.mockito.PowerMockito; -import org.powermock.api.support.membermodification.MemberModifier; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; -import org.powermock.reflect.Whitebox; - -import java.util.regex.Pattern; - -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.RETURNS_MOCKS; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -@RunWith(PowerMockRunner.class) -@PrepareForTest({AwesomeValidation.class, Range.class, ContextCompat.class}) -public class AwesomeValidationTest extends TestCase { - - private BasicValidator mSpiedBasicValidator; - private ColorationValidator mSpiedColorationValidator; - private UnderlabelValidator mSpiedUnderlabelValidator; - private TextInputLayoutValidator mSpiedTextInputLayoutValidator; - private AwesomeValidation mSpiedAwesomeValidationBasicStyle; - private AwesomeValidation mSpiedAwesomeValidationColorationStyle; - private AwesomeValidation mSpiedAwesomeValidationUnderlabelStyle; - private AwesomeValidation mSpiedAwesomeValidationTextInputLayoutStyle; - private Context mMockContext; - private int mColor = 256; - private int mColorResId = 512; - private int mStyleResId = 768; - private SimpleCustomValidation mEmptySimpleCustomValidation = new SimpleCustomValidation() { - @Override - public boolean compare(String input) { - return false; - } - }; - private CustomValidation mEmptyCustomValidation = new CustomValidation() { - @Override - public boolean compare(ValidationHolder validationHolder) { - return false; - } - }; - private CustomValidationCallback mEmptyCustomValidationCallback = new CustomValidationCallback() { - @Override - public void execute(ValidationHolder validationHolder) { - // intentionally empty, no need to test here - } - }; - private CustomErrorReset mEmptyCustomErrorReset = new CustomErrorReset() { - @Override - public void reset(ValidationHolder validationHolder) { - // intentionally empty, no need to test here - } - }; - - @Override - protected void setUp() throws Exception { - super.setUp(); - mSpiedBasicValidator = spy(BasicValidator.class); - mSpiedColorationValidator = spy(ColorationValidator.class); - mSpiedUnderlabelValidator = spy(UnderlabelValidator.class); - mSpiedTextInputLayoutValidator = spy(TextInputLayoutValidator.class); - mSpiedAwesomeValidationBasicStyle = spy(new AwesomeValidation(ValidationStyle.BASIC)); - mSpiedAwesomeValidationColorationStyle = spy(new AwesomeValidation(ValidationStyle.COLORATION)); - mSpiedAwesomeValidationUnderlabelStyle = spy(new AwesomeValidation(ValidationStyle.UNDERLABEL)); - mSpiedAwesomeValidationTextInputLayoutStyle = spy(new AwesomeValidation(ValidationStyle.TEXT_INPUT_LAYOUT)); - MemberModifier.field(AwesomeValidation.class, "mValidator").set(mSpiedAwesomeValidationBasicStyle, mSpiedBasicValidator); - MemberModifier.field(AwesomeValidation.class, "mValidator").set(mSpiedAwesomeValidationColorationStyle, mSpiedColorationValidator); - MemberModifier.field(AwesomeValidation.class, "mValidator").set(mSpiedAwesomeValidationUnderlabelStyle, mSpiedUnderlabelValidator); - MemberModifier.field(AwesomeValidation.class, "mValidator").set(mSpiedAwesomeValidationTextInputLayoutStyle, mSpiedTextInputLayoutValidator); - mMockContext = mock(Context.class); - } - - public void testAwesomeValidationConstructBasicStyle() { - assertTrue(Whitebox.getInternalState(mSpiedAwesomeValidationBasicStyle, "mValidator") instanceof BasicValidator); - } - - public void testAwesomeValidationConstructColorationStyle() { - assertTrue(Whitebox.getInternalState(mSpiedAwesomeValidationColorationStyle, "mValidator") instanceof ColorationValidator); - } - - public void testAwesomeValidationConstructUnderlabelValidatorStyle() { - assertTrue(Whitebox.getInternalState(mSpiedAwesomeValidationUnderlabelStyle, "mValidator") instanceof UnderlabelValidator); - } - - public void testAwesomeValidationConstructTextInputLayoutValidatorStyle() { - assertTrue(Whitebox.getInternalState(mSpiedAwesomeValidationTextInputLayoutStyle, "mValidator") instanceof TextInputLayoutValidator); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsColorationValidatorThrowsExceptionWithBasicStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationBasicStyle, "checkIsColorationValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsColorationValidatorThrowsExceptionWithUnderlabelStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationUnderlabelStyle, "checkIsColorationValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsColorationValidatorThrowsExceptionWithTextInputLayoutStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationTextInputLayoutStyle, "checkIsColorationValidator"); - } - - public void testCheckIsColorationValidatorWithoutException() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationColorationStyle, "checkIsColorationValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsUnderlabelValidatorThrowsExceptionWithBasicStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationBasicStyle, "checkIsUnderlabelValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsUnderlabelValidatorThrowsExceptionWithColorationStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationColorationStyle, "checkIsUnderlabelValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsUnderlabelValidatorThrowsExceptionWithTextInputLayoutStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationTextInputLayoutStyle, "checkIsUnderlabelValidator"); - } - - public void testCheckIsUnderlabelValidatorWithoutException() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationUnderlabelStyle, "checkIsUnderlabelValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsTextInputLayoutValidatorThrowsExceptionWithBasicStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationBasicStyle, "checkIsTextInputLayoutValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsTextInputLayoutValidatorThrowsExceptionWithColorationStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationColorationStyle, "checkIsTextInputLayoutValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsTextInputLayoutValidatorThrowsExceptionWithUnderlabelStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationUnderlabelStyle, "checkIsTextInputLayoutValidator"); - } - - public void testCheckIsTextInputLayoutValidatorWithoutException() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationTextInputLayoutStyle, "checkIsTextInputLayoutValidator"); - } - - @Test(expected = UnsupportedOperationException.class) - public void testCheckIsNotTextInputLayoutValidatorThrowsExceptionWithTextInputLayoutStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationTextInputLayoutStyle, "checkIsNotTextInputLayoutValidator"); - } - - public void testCheckIsNotTextInputLayoutValidatorWithoutExceptionWithBasicStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationBasicStyle, "checkIsNotTextInputLayoutValidator"); - } - - public void testCheckIsNotTextInputLayoutValidatorWithoutExceptionWithColorationStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationColorationStyle, "checkIsNotTextInputLayoutValidator"); - } - - public void testCheckIsNotTextInputLayoutValidatorWithoutExceptionWithUnderlabelStyle() throws Exception { - Whitebox.invokeMethod(mSpiedAwesomeValidationUnderlabelStyle, "checkIsNotTextInputLayoutValidator"); - } - - public void testSetContextForUnderlabelStyle() throws Exception { - PowerMockito.mockStatic(ContextCompat.class); - PowerMockito.when(ContextCompat.getColor(eq(mMockContext), anyInt())).thenReturn(mColor); - mSpiedAwesomeValidationUnderlabelStyle.setContext(mMockContext); - verify(mSpiedUnderlabelValidator, times(1)).setContext(mMockContext); - } - - @Test(expected = UnsupportedOperationException.class) - public void testSetContextForNonUnderlabelStyle() throws Exception { - mSpiedAwesomeValidationBasicStyle.setContext(mMockContext); - } - - public void testSetColorForColorationStyle() throws Exception { - mSpiedAwesomeValidationColorationStyle.setColor(mColor); - verify(mSpiedColorationValidator, times(1)).setColor(mColor); - } - - @Test(expected = UnsupportedOperationException.class) - public void testSetColorForNonColorationStyle() throws Exception { - mSpiedAwesomeValidationBasicStyle.setColor(mColor); - } - - public void testSetUnderlabelColorForUnderlabelStyle() throws Exception { - mSpiedAwesomeValidationUnderlabelStyle.setUnderlabelColor(mColor); - verify(mSpiedUnderlabelValidator, times(1)).setColor(mColor); - } - - @Test(expected = UnsupportedOperationException.class) - public void testSetUnderlabelColorForNonUnderlabelStyle() throws Exception { - mSpiedAwesomeValidationBasicStyle.setUnderlabelColor(mColor); - } - - public void testSetUnderlabelColorByResourceForUnderlabelStyle() throws Exception { - PowerMockito.mockStatic(ContextCompat.class); - PowerMockito.when(ContextCompat.getColor(eq(mMockContext), eq(mColorResId))).thenReturn(mColor); - mSpiedAwesomeValidationUnderlabelStyle.setContext(mMockContext); - mSpiedAwesomeValidationUnderlabelStyle.setUnderlabelColorByResource(mColorResId); - verify(mSpiedUnderlabelValidator, times(1)).setColorByResource(mColorResId); - } - - @Test(expected = UnsupportedOperationException.class) - public void testSetUnderlabelColorByResourceForNonUnderlabelStyle() throws Exception { - mSpiedAwesomeValidationBasicStyle.setUnderlabelColorByResource(mColorResId); - } - - public void testSetTextInputLayoutErrorTextAppearanceForTextInputLayoutStyle() throws Exception { - mSpiedAwesomeValidationTextInputLayoutStyle.setTextInputLayoutErrorTextAppearance(mStyleResId); - verify(mSpiedTextInputLayoutValidator, times(1)).setErrorTextAppearance(mStyleResId); - } - - @Test(expected = UnsupportedOperationException.class) - public void testSetTextInputLayoutErrorTextAppearanceForNonTextInputLayoutStyle() throws Exception { - mSpiedAwesomeValidationBasicStyle.setTextInputLayoutErrorTextAppearance(mStyleResId); - } - - public void testAddValidation() throws Exception { - Activity mockActivity = mock(Activity.class, RETURNS_MOCKS); - EditText mockEditText = mock(EditText.class, RETURNS_MOCKS); - View mockView = mock(View.class, RETURNS_MOCKS); - EditText mockConfirmationEditText = mock(EditText.class, RETURNS_MOCKS); - TextInputLayout mockTextInputLayout = mock(TextInputLayout.class, RETURNS_MOCKS); - TextInputLayout mockConfirmationTextInputLayout = mock(TextInputLayout.class, RETURNS_MOCKS); - Pattern mockPattern = PowerMockito.mock(Pattern.class, RETURNS_MOCKS); - Range mockRange = PowerMockito.mock(Range.class, RETURNS_MOCKS); - String mockRegex = PowerMockito.mock(String.class); - String mockErrMsg = PowerMockito.mock(String.class); - NumericRange mockNumericRange = mock(NumericRange.class); - int viewId = 65535; - int confirmationViewId = 65536; - int errMsgId = 32768; - when(mockActivity.findViewById(viewId)).thenReturn(mockEditText); - when(mockActivity.findViewById(confirmationViewId)).thenReturn(mockConfirmationEditText); - PowerMockito.whenNew(NumericRange.class).withArguments(mockRange).thenReturn(mockNumericRange); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockEditText, mockRegex, mockErrMsg); - verify(mSpiedBasicValidator, times(1)).set(mockEditText, mockRegex, mockErrMsg); - - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockTextInputLayout, mockRegex, mockErrMsg); - verify(mSpiedTextInputLayoutValidator, times(1)).set(mockTextInputLayout, mockRegex, mockErrMsg); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mockRegex, errMsgId); - verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, mockRegex, errMsgId); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockEditText, mockPattern, mockErrMsg); - verify(mSpiedBasicValidator, times(1)).set(mockEditText, mockPattern, mockErrMsg); - - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockTextInputLayout, mockPattern, mockErrMsg); - verify(mSpiedTextInputLayoutValidator, times(1)).set(mockTextInputLayout, mockPattern, mockErrMsg); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mockPattern, errMsgId); - verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, mockPattern, errMsgId); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockEditText, mockRange, mockErrMsg); - verify(mSpiedBasicValidator, times(1)).set(mockEditText, new NumericRange(mockRange), mockErrMsg); - - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockTextInputLayout, mockRange, mockErrMsg); - verify(mSpiedTextInputLayoutValidator, times(1)).set(mockTextInputLayout, new NumericRange(mockRange), mockErrMsg); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mockRange, errMsgId); - verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, new NumericRange(mockRange), errMsgId); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockConfirmationEditText, mockEditText, mockErrMsg); - verify(mSpiedBasicValidator, times(1)).set(mockConfirmationEditText, mockEditText, mockErrMsg); - - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockConfirmationTextInputLayout, mockTextInputLayout, mockErrMsg); - verify(mSpiedTextInputLayoutValidator, times(1)).set(mockConfirmationTextInputLayout, mockTextInputLayout, mockErrMsg); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, confirmationViewId, viewId, errMsgId); - verify(mSpiedBasicValidator, times(1)).set(mockActivity, confirmationViewId, viewId, errMsgId); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockEditText, mEmptySimpleCustomValidation, mockErrMsg); - verify(mSpiedBasicValidator, times(1)).set(mockEditText, mEmptySimpleCustomValidation, mockErrMsg); - - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockTextInputLayout, mEmptySimpleCustomValidation, mockErrMsg); - verify(mSpiedTextInputLayoutValidator, times(1)).set(mockTextInputLayout, mEmptySimpleCustomValidation, mockErrMsg); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mEmptySimpleCustomValidation, errMsgId); - verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, mEmptySimpleCustomValidation, errMsgId); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockView, mEmptyCustomValidation, mEmptyCustomValidationCallback, mEmptyCustomErrorReset, mockErrMsg); - verify(mSpiedBasicValidator, times(1)).set(mockView, mEmptyCustomValidation, mEmptyCustomValidationCallback, mEmptyCustomErrorReset, mockErrMsg); - - mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mEmptyCustomValidation, mEmptyCustomValidationCallback, mEmptyCustomErrorReset, errMsgId); - verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, mEmptyCustomValidation, mEmptyCustomValidationCallback, mEmptyCustomErrorReset, errMsgId); - } - - @Test(expected = UnsupportedOperationException.class) - public void testAddValidationForTextInputLayoutValidatorWithEditTextAndRegexThrowsException() { - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mock(EditText.class), PowerMockito.mock(String.class), PowerMockito.mock(String.class)); - } - - @Test(expected = UnsupportedOperationException.class) - public void testAddValidationForTextInputLayoutValidatorWithEditTextAndPatternThrowsException() { - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mock(EditText.class), PowerMockito.mock(Pattern.class), PowerMockito.mock(String.class)); - } - - @Test(expected = UnsupportedOperationException.class) - public void testAddValidationForTextInputLayoutValidatorWithEditTextAndRangeThrowsException() { - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mock(EditText.class), PowerMockito.mock(Range.class), PowerMockito.mock(String.class)); - } - - @Test(expected = UnsupportedOperationException.class) - public void testAddValidationForTextInputLayoutValidatorWithEditTextAndConfirmationThrowsException() { - mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mock(EditText.class), mock(EditText.class), PowerMockito.mock(String.class)); - } - - @Test(expected = UnsupportedOperationException.class) - public void testAddValidationForNonTextInputLayoutValidatorWithTextInputLayoutAndRegexThrowsException() { - mSpiedAwesomeValidationBasicStyle.addValidation(mock(TextInputLayout.class), PowerMockito.mock(String.class), PowerMockito.mock(String.class)); - } - - @Test(expected = UnsupportedOperationException.class) - public void testAddValidationForNonTextInputLayoutValidatorWithTextInputLayoutAndPatternThrowsException() { - mSpiedAwesomeValidationColorationStyle.addValidation(mock(TextInputLayout.class), PowerMockito.mock(Pattern.class), PowerMockito.mock(String.class)); - } - - @Test(expected = UnsupportedOperationException.class) - public void testAddValidationForNonTextInputLayoutValidatorWithTextInputLayoutAndRangeThrowsException() { - mSpiedAwesomeValidationUnderlabelStyle.addValidation(mock(TextInputLayout.class), PowerMockito.mock(Range.class), PowerMockito.mock(String.class)); - } - - @Test(expected = UnsupportedOperationException.class) - public void testAddValidationForNonTextInputLayoutValidatorWithTextInputLayoutAndConfirmationThrowsException() { - mSpiedAwesomeValidationBasicStyle.addValidation(mock(TextInputLayout.class), mock(TextInputLayout.class), PowerMockito.mock(String.class)); - } - - public void testValidate() { - mSpiedAwesomeValidationBasicStyle.validate(); - verify(mSpiedBasicValidator, times(1)).trigger(); - assertEquals(mSpiedBasicValidator.trigger(), mSpiedAwesomeValidationBasicStyle.validate()); - } - - public void testClear() throws Exception { - mSpiedAwesomeValidationBasicStyle.clear(); - verify(mSpiedBasicValidator, times(1)).halt(); - } - -} diff --git a/library/src/test/java/com/basgeekball/awesomevalidation/AwesomeValidationTest.kt b/library/src/test/java/com/basgeekball/awesomevalidation/AwesomeValidationTest.kt new file mode 100644 index 0000000..0826537 --- /dev/null +++ b/library/src/test/java/com/basgeekball/awesomevalidation/AwesomeValidationTest.kt @@ -0,0 +1,375 @@ +package com.basgeekball.awesomevalidation + +import android.app.Activity +import android.content.Context +import android.support.design.widget.TextInputLayout +import android.support.v4.content.ContextCompat +import android.view.View +import android.widget.EditText +import com.basgeekball.awesomevalidation.model.NumericRange +import com.basgeekball.awesomevalidation.utility.custom.CustomErrorReset +import com.basgeekball.awesomevalidation.utility.custom.CustomValidation +import com.basgeekball.awesomevalidation.utility.custom.CustomValidationCallback +import com.basgeekball.awesomevalidation.utility.custom.SimpleCustomValidation +import com.basgeekball.awesomevalidation.validators.BasicValidator +import com.basgeekball.awesomevalidation.validators.ColorationValidator +import com.basgeekball.awesomevalidation.validators.TextInputLayoutValidator +import com.basgeekball.awesomevalidation.validators.UnderlabelValidator +import com.google.common.collect.Range +import com.nhaarman.mockitokotlin2.* +import junit.framework.TestCase +import org.easymock.EasyMock.anyInt +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.Mockito.RETURNS_MOCKS +import org.powermock.api.mockito.PowerMockito +import org.powermock.api.support.membermodification.MemberModifier +import org.powermock.core.classloader.annotations.PrepareForTest +import org.powermock.modules.junit4.PowerMockRunner +import org.powermock.reflect.Whitebox +import java.util.regex.Pattern + +@RunWith(PowerMockRunner::class) +@PrepareForTest(AwesomeValidation::class, Range::class, ContextCompat::class) +class AwesomeValidationTest : TestCase() { + + private lateinit var mSpiedBasicValidator: BasicValidator + private lateinit var mSpiedColorationValidator: ColorationValidator + private lateinit var mSpiedUnderlabelValidator: UnderlabelValidator + private lateinit var mSpiedTextInputLayoutValidator: TextInputLayoutValidator + private lateinit var mSpiedAwesomeValidationBasicStyle: AwesomeValidation + private lateinit var mSpiedAwesomeValidationColorationStyle: AwesomeValidation + private lateinit var mSpiedAwesomeValidationUnderlabelStyle: AwesomeValidation + private lateinit var mSpiedAwesomeValidationTextInputLayoutStyle: AwesomeValidation + private lateinit var mMockContext: Context + private val mColor = 256 + private val mColorResId = 512 + private val mStyleResId = 768 + + private val mEmptySimpleCustomValidation = SimpleCustomValidation { false } + private val mEmptyCustomValidation = CustomValidation { false } + private val mEmptyCustomValidationCallback = CustomValidationCallback { + // intentionally empty, no need to test here + } + private val mEmptyCustomErrorReset = CustomErrorReset { + // intentionally empty, no need to test here + } + + override fun setUp() { + super.setUp() + + mSpiedBasicValidator = spy() + mSpiedColorationValidator = spy() + mSpiedUnderlabelValidator = spy() + mSpiedTextInputLayoutValidator = spy() + mSpiedAwesomeValidationBasicStyle = spy(AwesomeValidation(ValidationStyle.BASIC)) + mSpiedAwesomeValidationColorationStyle = spy(AwesomeValidation(ValidationStyle.COLORATION)) + mSpiedAwesomeValidationUnderlabelStyle = spy(AwesomeValidation(ValidationStyle.UNDERLABEL)) + mSpiedAwesomeValidationTextInputLayoutStyle = spy(AwesomeValidation(ValidationStyle.TEXT_INPUT_LAYOUT)) + + MemberModifier.field(AwesomeValidation::class.java, "mValidator").set(mSpiedAwesomeValidationBasicStyle, mSpiedBasicValidator) + MemberModifier.field(AwesomeValidation::class.java, "mValidator").set(mSpiedAwesomeValidationColorationStyle, mSpiedColorationValidator) + MemberModifier.field(AwesomeValidation::class.java, "mValidator").set(mSpiedAwesomeValidationUnderlabelStyle, mSpiedUnderlabelValidator) + MemberModifier.field(AwesomeValidation::class.java, "mValidator").set(mSpiedAwesomeValidationTextInputLayoutStyle, mSpiedTextInputLayoutValidator) + mMockContext = mock() + } + + fun testAwesomeValidationConstructBasicStyle() { + assertTrue(Whitebox.getInternalState(mSpiedAwesomeValidationBasicStyle, "mValidator") is BasicValidator) + } + + fun testAwesomeValidationConstructColorationStyle() { + assertTrue(Whitebox.getInternalState(mSpiedAwesomeValidationColorationStyle, "mValidator") is ColorationValidator) + } + + fun testAwesomeValidationConstructUnderlabelValidatorStyle() { + assertTrue(Whitebox.getInternalState(mSpiedAwesomeValidationUnderlabelStyle, "mValidator") is UnderlabelValidator) + } + + fun testAwesomeValidationConstructTextInputLayoutValidatorStyle() { + assertTrue(Whitebox.getInternalState(mSpiedAwesomeValidationTextInputLayoutStyle, "mValidator") is TextInputLayoutValidator) + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsColorationValidatorThrowsExceptionWithBasicStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationBasicStyle, "checkIsColorationValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsColorationValidatorThrowsExceptionWithUnderlabelStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationUnderlabelStyle, "checkIsColorationValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsColorationValidatorThrowsExceptionWithTextInputLayoutStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationTextInputLayoutStyle, "checkIsColorationValidator") + } + + @Throws(Exception::class) + fun testCheckIsColorationValidatorWithoutException() { + Whitebox.invokeMethod(mSpiedAwesomeValidationColorationStyle, "checkIsColorationValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsUnderlabelValidatorThrowsExceptionWithBasicStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationBasicStyle, "checkIsUnderlabelValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsUnderlabelValidatorThrowsExceptionWithColorationStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationColorationStyle, "checkIsUnderlabelValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsUnderlabelValidatorThrowsExceptionWithTextInputLayoutStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationTextInputLayoutStyle, "checkIsUnderlabelValidator") + } + + @Throws(Exception::class) + fun testCheckIsUnderlabelValidatorWithoutException() { + Whitebox.invokeMethod(mSpiedAwesomeValidationUnderlabelStyle, "checkIsUnderlabelValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsTextInputLayoutValidatorThrowsExceptionWithBasicStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationBasicStyle, "checkIsTextInputLayoutValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsTextInputLayoutValidatorThrowsExceptionWithColorationStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationColorationStyle, "checkIsTextInputLayoutValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsTextInputLayoutValidatorThrowsExceptionWithUnderlabelStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationUnderlabelStyle, "checkIsTextInputLayoutValidator") + } + + @Throws(Exception::class) + fun testCheckIsTextInputLayoutValidatorWithoutException() { + Whitebox.invokeMethod(mSpiedAwesomeValidationTextInputLayoutStyle, "checkIsTextInputLayoutValidator") + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testCheckIsNotTextInputLayoutValidatorThrowsExceptionWithTextInputLayoutStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationTextInputLayoutStyle, "checkIsNotTextInputLayoutValidator") + } + + @Throws(Exception::class) + fun testCheckIsNotTextInputLayoutValidatorWithoutExceptionWithBasicStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationBasicStyle, "checkIsNotTextInputLayoutValidator") + } + + @Throws(Exception::class) + fun testCheckIsNotTextInputLayoutValidatorWithoutExceptionWithColorationStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationColorationStyle, "checkIsNotTextInputLayoutValidator") + } + + @Throws(Exception::class) + fun testCheckIsNotTextInputLayoutValidatorWithoutExceptionWithUnderlabelStyle() { + Whitebox.invokeMethod(mSpiedAwesomeValidationUnderlabelStyle, "checkIsNotTextInputLayoutValidator") + } + + @Throws(Exception::class) + fun testSetContextForUnderlabelStyle() { + PowerMockito.mockStatic(ContextCompat::class.java) + PowerMockito.`when`(ContextCompat.getColor(eq(mMockContext), eq(anyInt()))).thenReturn(mColor) + mSpiedAwesomeValidationUnderlabelStyle.setContext(mMockContext) + verify(mSpiedUnderlabelValidator, times(1)).setContext(mMockContext) + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testSetContextForNonUnderlabelStyle() { + mSpiedAwesomeValidationBasicStyle.setContext(mMockContext) + } + + @Throws(Exception::class) + fun testSetColorForColorationStyle() { + mSpiedAwesomeValidationColorationStyle.setColor(mColor) + verify(mSpiedColorationValidator, times(1)).setColor(mColor) + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testSetColorForNonColorationStyle() { + mSpiedAwesomeValidationBasicStyle.setColor(mColor) + } + + @Throws(Exception::class) + fun testSetUnderlabelColorForUnderlabelStyle() { + mSpiedAwesomeValidationUnderlabelStyle.setUnderlabelColor(mColor) + verify(mSpiedUnderlabelValidator, times(1)).setColor(mColor) + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testSetUnderlabelColorForNonUnderlabelStyle() { + mSpiedAwesomeValidationBasicStyle.setUnderlabelColor(mColor) + } + + @Throws(Exception::class) + fun testSetUnderlabelColorByResourceForUnderlabelStyle() { + PowerMockito.mockStatic(ContextCompat::class.java) + PowerMockito.`when`(ContextCompat.getColor(eq(mMockContext), eq(mColorResId))).thenReturn(mColor) + mSpiedAwesomeValidationUnderlabelStyle.setContext(mMockContext) + mSpiedAwesomeValidationUnderlabelStyle.setUnderlabelColorByResource(mColorResId) + verify(mSpiedUnderlabelValidator, times(1)).setColorByResource(mColorResId) + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testSetUnderlabelColorByResourceForNonUnderlabelStyle() { + mSpiedAwesomeValidationBasicStyle.setUnderlabelColorByResource(mColorResId) + } + + @Throws(Exception::class) + fun testSetTextInputLayoutErrorTextAppearanceForTextInputLayoutStyle() { + mSpiedAwesomeValidationTextInputLayoutStyle.setTextInputLayoutErrorTextAppearance(mStyleResId) + verify(mSpiedTextInputLayoutValidator, times(1)).setErrorTextAppearance(mStyleResId) + } + + @Test(expected = UnsupportedOperationException::class) + @Throws(Exception::class) + fun testSetTextInputLayoutErrorTextAppearanceForNonTextInputLayoutStyle() { + mSpiedAwesomeValidationBasicStyle.setTextInputLayoutErrorTextAppearance(mStyleResId) + } + + @Throws(Exception::class) + fun testAddValidation() { + val viewId = 65535 + val confirmationViewId = 65536 + val errMsgId = 32768 + + val mockView = PowerMockito.mock(View::class.java, RETURNS_MOCKS) + val mockEditText = PowerMockito.mock(EditText::class.java, RETURNS_MOCKS) + val mockConfirmationEditText = PowerMockito.mock(EditText::class.java, RETURNS_MOCKS) + val mockTextInputLayout = PowerMockito.mock(TextInputLayout::class.java, RETURNS_MOCKS) + val mockConfirmationTextInputLayout = PowerMockito.mock(TextInputLayout::class.java, RETURNS_MOCKS) + val mockPattern = PowerMockito.mock(Pattern::class.java, RETURNS_MOCKS) + val mockRange = PowerMockito.mock>(Range::class.java, RETURNS_MOCKS) + val mockRegex = PowerMockito.mock(String::class.java) + val mockErrMsg = PowerMockito.mock(String::class.java) + val mockNumericRange = mock() + + val mockActivity = PowerMockito.mock(Activity::class.java, RETURNS_MOCKS).apply { + whenever(findViewById(viewId)).thenReturn(mockEditText) + whenever(findViewById(confirmationViewId)).thenReturn(mockConfirmationEditText) + } + + PowerMockito.whenNew(NumericRange::class.java).withArguments(mockRange).thenReturn(mockNumericRange) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockEditText, mockRegex, mockErrMsg) + verify(mSpiedBasicValidator, times(1)).set(mockEditText, mockRegex, mockErrMsg) + + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockTextInputLayout, mockRegex, mockErrMsg) + verify(mSpiedTextInputLayoutValidator, times(1)).set(mockTextInputLayout, mockRegex, mockErrMsg) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mockRegex, errMsgId) + verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, mockRegex, errMsgId) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockEditText, mockPattern, mockErrMsg) + verify(mSpiedBasicValidator, times(1)).set(mockEditText, mockPattern, mockErrMsg) + + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockTextInputLayout, mockPattern, mockErrMsg) + verify(mSpiedTextInputLayoutValidator, times(1)).set(mockTextInputLayout, mockPattern, mockErrMsg) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mockPattern, errMsgId) + verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, mockPattern, errMsgId) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockEditText, mockRange, mockErrMsg) + verify(mSpiedBasicValidator, times(1)).set(mockEditText, NumericRange(mockRange), mockErrMsg) + + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockTextInputLayout, mockRange, mockErrMsg) + verify(mSpiedTextInputLayoutValidator, times(1)).set(mockTextInputLayout, NumericRange(mockRange), mockErrMsg) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mockRange, errMsgId) + verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, NumericRange(mockRange), errMsgId) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockConfirmationEditText, mockEditText, mockErrMsg) + verify(mSpiedBasicValidator, times(1)).set(mockConfirmationEditText, mockEditText, mockErrMsg) + + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockConfirmationTextInputLayout, mockTextInputLayout, mockErrMsg) + verify(mSpiedTextInputLayoutValidator, times(1)).set(mockConfirmationTextInputLayout, mockTextInputLayout, mockErrMsg) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, confirmationViewId, viewId, errMsgId) + verify(mSpiedBasicValidator, times(1)).set(mockActivity, confirmationViewId, viewId, errMsgId) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockEditText, mEmptySimpleCustomValidation, mockErrMsg) + verify(mSpiedBasicValidator, times(1)).set(mockEditText, mEmptySimpleCustomValidation, mockErrMsg) + + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mockTextInputLayout, mEmptySimpleCustomValidation, mockErrMsg) + verify(mSpiedTextInputLayoutValidator, times(1)).set(mockTextInputLayout, mEmptySimpleCustomValidation, mockErrMsg) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mEmptySimpleCustomValidation, errMsgId) + verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, mEmptySimpleCustomValidation, errMsgId) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockView, mEmptyCustomValidation, mEmptyCustomValidationCallback, mEmptyCustomErrorReset, mockErrMsg) + verify(mSpiedBasicValidator, times(1)).set(mockView, mEmptyCustomValidation, mEmptyCustomValidationCallback, mEmptyCustomErrorReset, mockErrMsg) + + mSpiedAwesomeValidationBasicStyle.addValidation(mockActivity, viewId, mEmptyCustomValidation, mEmptyCustomValidationCallback, mEmptyCustomErrorReset, errMsgId) + verify(mSpiedBasicValidator, times(1)).set(mockActivity, viewId, mEmptyCustomValidation, mEmptyCustomValidationCallback, mEmptyCustomErrorReset, errMsgId) + } + + @Test(expected = UnsupportedOperationException::class) + fun testAddValidationForTextInputLayoutValidatorWithEditTextAndRegexThrowsException() { + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mock(), PowerMockito.mock(String::class.java), PowerMockito.mock(String::class.java)) + } + + @Test(expected = UnsupportedOperationException::class) + fun testAddValidationForTextInputLayoutValidatorWithEditTextAndPatternThrowsException() { + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mock(), PowerMockito.mock(Pattern::class.java), PowerMockito.mock(String::class.java)) + } + + @Test(expected = UnsupportedOperationException::class) + fun testAddValidationForTextInputLayoutValidatorWithEditTextAndRangeThrowsException() { + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mock(), PowerMockito.mock(Range::class.java), PowerMockito.mock(String::class.java)) + } + + @Test(expected = UnsupportedOperationException::class) + fun testAddValidationForTextInputLayoutValidatorWithEditTextAndConfirmationThrowsException() { + mSpiedAwesomeValidationTextInputLayoutStyle.addValidation(mock(), mock(), PowerMockito.mock(String::class.java)) + } + + @Test(expected = UnsupportedOperationException::class) + fun testAddValidationForNonTextInputLayoutValidatorWithTextInputLayoutAndRegexThrowsException() { + mSpiedAwesomeValidationBasicStyle.addValidation(mock(), PowerMockito.mock(String::class.java), PowerMockito.mock(String::class.java)) + } + + @Test(expected = UnsupportedOperationException::class) + fun testAddValidationForNonTextInputLayoutValidatorWithTextInputLayoutAndPatternThrowsException() { + mSpiedAwesomeValidationColorationStyle.addValidation(mock(), PowerMockito.mock(Pattern::class.java), PowerMockito.mock(String::class.java)) + } + + @Test(expected = UnsupportedOperationException::class) + fun testAddValidationForNonTextInputLayoutValidatorWithTextInputLayoutAndRangeThrowsException() { + mSpiedAwesomeValidationUnderlabelStyle.addValidation(mock(), PowerMockito.mock(Range::class.java), PowerMockito.mock(String::class.java)) + } + + @Test(expected = UnsupportedOperationException::class) + fun testAddValidationForNonTextInputLayoutValidatorWithTextInputLayoutAndConfirmationThrowsException() { + mSpiedAwesomeValidationBasicStyle.addValidation(mock(), mock(), PowerMockito.mock(String::class.java)) + } + + fun testValidate() { + mSpiedAwesomeValidationBasicStyle.validate() + verify(mSpiedBasicValidator, times(1)).trigger() + assertEquals(mSpiedBasicValidator.trigger(), mSpiedAwesomeValidationBasicStyle.validate()) + } + + @Throws(Exception::class) + fun testClear() { + mSpiedAwesomeValidationBasicStyle.clear() + verify(mSpiedBasicValidator, times(1)).halt() + } +} \ No newline at end of file diff --git a/library/src/test/java/com/basgeekball/awesomevalidation/ValidationHolderTest.java b/library/src/test/java/com/basgeekball/awesomevalidation/ValidationHolderTest.java deleted file mode 100644 index c3fcffc..0000000 --- a/library/src/test/java/com/basgeekball/awesomevalidation/ValidationHolderTest.java +++ /dev/null @@ -1,342 +0,0 @@ -package com.basgeekball.awesomevalidation; - -import android.support.design.widget.TextInputLayout; -import android.text.Editable; -import android.view.View; -import android.widget.EditText; - -import com.basgeekball.awesomevalidation.exception.BadLayoutException; -import com.basgeekball.awesomevalidation.model.NumericRange; -import com.basgeekball.awesomevalidation.utility.custom.CustomErrorReset; -import com.basgeekball.awesomevalidation.utility.custom.CustomValidation; -import com.basgeekball.awesomevalidation.utility.custom.CustomValidationCallback; -import com.basgeekball.awesomevalidation.utility.custom.SimpleCustomValidation; - -import junit.framework.TestCase; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.powermock.api.easymock.PowerMock; -import org.powermock.core.classloader.annotations.PrepareForTest; -import org.powermock.modules.junit4.PowerMockRunner; - -import java.util.regex.Pattern; - -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -@RunWith(PowerMockRunner.class) -@PrepareForTest(ValidationHolder.class) -public class ValidationHolderTest extends TestCase { - - private EditText mMockEditText; - private EditText mMockConfirmationEditText; - private TextInputLayout mMockTextInputLayout; - private TextInputLayout mMockConfirmationTextInputLayout; - private View mMockView; - private CustomErrorReset mMockCustomErrorReset; - private ValidationHolder mValidationHolderRegexTypeWithEditText; - private ValidationHolder mValidationHolderRangeTypeWithEditText; - private ValidationHolder mValidationHolderConfirmationTypeWithEditText; - private ValidationHolder mValidationHolderSimpleCustomTypeWithEditText; - private ValidationHolder mValidationHolderRegexTypeWithTextInputLayout; - private ValidationHolder mValidationHolderRangeTypeWithTextInputLayout; - private ValidationHolder mValidationHolderConfirmationTypeWithTextInputLayout; - private ValidationHolder mValidationHolderSimpleCustomTypeWithTextInputLayout; - private ValidationHolder mValidationHolderCustomTypeWithSomeSortOfView; - - @Override - protected void setUp() throws Exception { - super.setUp(); - mMockEditText = mock(EditText.class); - mMockConfirmationEditText = mock(EditText.class); - mMockTextInputLayout = mock(TextInputLayout.class); - mMockConfirmationTextInputLayout = mock(TextInputLayout.class); - mMockView = mock(View.class); - Pattern mockPattern = PowerMock.createMock(Pattern.class); - NumericRange mockNumericRange = mock(NumericRange.class); - SimpleCustomValidation mockSimpleCustomValidation = mock(SimpleCustomValidation.class); - CustomValidation mockCustomValidation = mock(CustomValidation.class); - CustomValidationCallback mockCustomValidationCallback = mock(CustomValidationCallback.class); - mMockCustomErrorReset = mock(CustomErrorReset.class); - String mockErrMsg = PowerMock.createMock(String.class); - mValidationHolderRegexTypeWithEditText = new ValidationHolder(mMockEditText, mockPattern, mockErrMsg); - mValidationHolderRangeTypeWithEditText = new ValidationHolder(mMockEditText, mockNumericRange, mockErrMsg); - mValidationHolderConfirmationTypeWithEditText = new ValidationHolder(mMockConfirmationEditText, mMockEditText, mockErrMsg); - mValidationHolderSimpleCustomTypeWithEditText = new ValidationHolder(mMockEditText, mockSimpleCustomValidation, mockErrMsg); - mValidationHolderRegexTypeWithTextInputLayout = new ValidationHolder(mMockTextInputLayout, mockPattern, mockErrMsg); - mValidationHolderRangeTypeWithTextInputLayout = new ValidationHolder(mMockTextInputLayout, mockNumericRange, mockErrMsg); - mValidationHolderConfirmationTypeWithTextInputLayout = new ValidationHolder(mMockConfirmationTextInputLayout, mMockTextInputLayout, mockErrMsg); - mValidationHolderSimpleCustomTypeWithTextInputLayout = new ValidationHolder(mMockTextInputLayout, mockSimpleCustomValidation, mockErrMsg); - mValidationHolderCustomTypeWithSomeSortOfView = new ValidationHolder(mMockView, mockCustomValidation, mockCustomValidationCallback, mMockCustomErrorReset, mockErrMsg); - } - - public void testIsRegexTypeTrue() { - assertTrue(mValidationHolderRegexTypeWithEditText.isRegexType()); - assertTrue(mValidationHolderRegexTypeWithTextInputLayout.isRegexType()); - } - - public void testIsRegexTypeFalse() { - assertFalse(mValidationHolderRangeTypeWithEditText.isRegexType()); - assertFalse(mValidationHolderConfirmationTypeWithEditText.isRegexType()); - assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isRegexType()); - assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isRegexType()); - assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isRegexType()); - assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isRegexType()); - assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isRegexType()); - } - - public void testIsRangeTypeTrue() { - assertTrue(mValidationHolderRangeTypeWithEditText.isRangeType()); - assertTrue(mValidationHolderRangeTypeWithTextInputLayout.isRangeType()); - } - - public void testIsRangeTypeFalse() { - assertFalse(mValidationHolderRegexTypeWithEditText.isRangeType()); - assertFalse(mValidationHolderConfirmationTypeWithEditText.isRangeType()); - assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isRangeType()); - assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isRangeType()); - assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isRangeType()); - assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isRangeType()); - assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isRangeType()); - } - - public void testIsConfirmationTypeTrue() { - assertTrue(mValidationHolderConfirmationTypeWithEditText.isConfirmationType()); - assertTrue(mValidationHolderConfirmationTypeWithTextInputLayout.isConfirmationType()); - } - - public void testIsConfirmationTypeFalse() { - assertFalse(mValidationHolderRegexTypeWithEditText.isConfirmationType()); - assertFalse(mValidationHolderRangeTypeWithEditText.isConfirmationType()); - assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isConfirmationType()); - assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isConfirmationType()); - assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isConfirmationType()); - assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isConfirmationType()); - assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isConfirmationType()); - } - - public void testIsSimpleCustomTypeTrue() { - assertTrue(mValidationHolderSimpleCustomTypeWithEditText.isSimpleCustomType()); - assertTrue(mValidationHolderSimpleCustomTypeWithTextInputLayout.isSimpleCustomType()); - } - - public void testIsSimpleCustomTypeFalse() { - assertFalse(mValidationHolderRegexTypeWithEditText.isSimpleCustomType()); - assertFalse(mValidationHolderRangeTypeWithEditText.isSimpleCustomType()); - assertFalse(mValidationHolderConfirmationTypeWithEditText.isSimpleCustomType()); - assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isSimpleCustomType()); - assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isSimpleCustomType()); - assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isSimpleCustomType()); - assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isSimpleCustomType()); - } - - public void testIsCustomTypeTrue() { - assertTrue(mValidationHolderCustomTypeWithSomeSortOfView.isCustomType()); - } - - public void testIsCustomTypeFalse() { - assertFalse(mValidationHolderRegexTypeWithEditText.isCustomType()); - assertFalse(mValidationHolderRangeTypeWithEditText.isCustomType()); - assertFalse(mValidationHolderConfirmationTypeWithEditText.isCustomType()); - assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isCustomType()); - assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isCustomType()); - assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isCustomType()); - assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isCustomType()); - assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isCustomType()); - } - - public void testIsEditTextViewTrue() { - assertTrue(mValidationHolderRegexTypeWithEditText.isEditTextView()); - assertTrue(mValidationHolderRangeTypeWithEditText.isEditTextView()); - assertTrue(mValidationHolderConfirmationTypeWithEditText.isEditTextView()); - assertTrue(mValidationHolderSimpleCustomTypeWithEditText.isEditTextView()); - } - - public void testIsEditTextViewFalse() { - assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isEditTextView()); - assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isEditTextView()); - assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isEditTextView()); - assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isEditTextView()); - assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isEditTextView()); - } - - public void testIsTextInputLayoutViewTrue() { - assertTrue(mValidationHolderRegexTypeWithTextInputLayout.isTextInputLayoutView()); - assertTrue(mValidationHolderRangeTypeWithTextInputLayout.isTextInputLayoutView()); - assertTrue(mValidationHolderConfirmationTypeWithTextInputLayout.isTextInputLayoutView()); - assertTrue(mValidationHolderSimpleCustomTypeWithTextInputLayout.isTextInputLayoutView()); - } - - public void testIsTextInputLayoutViewFalse() { - assertFalse(mValidationHolderRegexTypeWithEditText.isTextInputLayoutView()); - assertFalse(mValidationHolderRangeTypeWithEditText.isTextInputLayoutView()); - assertFalse(mValidationHolderConfirmationTypeWithEditText.isTextInputLayoutView()); - assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isTextInputLayoutView()); - assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isTextInputLayoutView()); - } - - public void testIsSomeSortOfViewTrue() { - assertTrue(mValidationHolderCustomTypeWithSomeSortOfView.isSomeSortOfView()); - } - - public void testIsSomeSortOfViewFalse() { - assertFalse(mValidationHolderRegexTypeWithEditText.isSomeSortOfView()); - assertFalse(mValidationHolderRangeTypeWithEditText.isSomeSortOfView()); - assertFalse(mValidationHolderConfirmationTypeWithEditText.isSomeSortOfView()); - assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isSomeSortOfView()); - assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isSomeSortOfView()); - assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isSomeSortOfView()); - assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isSomeSortOfView()); - assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isSomeSortOfView()); - } - - public void testGetTextFromEditText() { - String text = "OK"; - Editable mockEditable = mock(Editable.class); - when(mMockEditText.getText()).thenReturn(mockEditable); - when(mockEditable.toString()).thenReturn(text); - assertEquals(text, mValidationHolderRegexTypeWithEditText.getText()); - assertEquals(text, mValidationHolderRangeTypeWithEditText.getText()); - assertEquals(text, mValidationHolderConfirmationTypeWithEditText.getText()); - assertEquals(text, mValidationHolderSimpleCustomTypeWithEditText.getText()); - } - - public void testGetTextFromTextInputLayout() { - String text = "OK"; - EditText mockEditText = mock(EditText.class); - Editable mockEditable = mock(Editable.class); - when(mMockTextInputLayout.getEditText()).thenReturn(mockEditText); - when(mockEditText.getText()).thenReturn(mockEditable); - when(mockEditable.toString()).thenReturn(text); - assertEquals(text, mValidationHolderRegexTypeWithTextInputLayout.getText()); - assertEquals(text, mValidationHolderRangeTypeWithTextInputLayout.getText()); - assertEquals(text, mValidationHolderConfirmationTypeWithTextInputLayout.getText()); - assertEquals(text, mValidationHolderSimpleCustomTypeWithTextInputLayout.getText()); - } - - @Test(expected = BadLayoutException.class) - public void testGetTextFromTextInputLayoutThrowsException() { - when(mMockTextInputLayout.getEditText()).thenReturn(null); - mValidationHolderRegexTypeWithTextInputLayout.getText(); - } - - public void testGetTextReturnsNull() { - EditText mockEditText = null; - TextInputLayout mockTextInputLayout = null; - Pattern mockPattern = PowerMock.createMock(Pattern.class); - String mockErrMsg = PowerMock.createMock(String.class); - mValidationHolderRegexTypeWithEditText = new ValidationHolder(mockEditText, mockPattern, mockErrMsg); - mValidationHolderRegexTypeWithTextInputLayout = new ValidationHolder(mockTextInputLayout, mockPattern, mockErrMsg); - assertNull(mValidationHolderRegexTypeWithEditText.getText()); - assertNull(mValidationHolderRegexTypeWithTextInputLayout.getText()); - } - - public void testGetConfirmationTextFromEditText() { - String text = "OK"; - Editable mockEditable = mock(Editable.class); - when(mMockConfirmationEditText.getText()).thenReturn(mockEditable); - when(mockEditable.toString()).thenReturn(text); - assertEquals(text, mValidationHolderConfirmationTypeWithEditText.getConfirmationText()); - } - - public void testGetConfirmationTextFromTextInputLayout() { - String text = "OK"; - EditText mockEditText = mock(EditText.class); - Editable mockEditable = mock(Editable.class); - when(mMockConfirmationTextInputLayout.getEditText()).thenReturn(mockEditText); - when(mockEditText.getText()).thenReturn(mockEditable); - when(mockEditable.toString()).thenReturn(text); - assertEquals(text, mValidationHolderConfirmationTypeWithTextInputLayout.getConfirmationText()); - } - - @Test(expected = BadLayoutException.class) - public void testGetConfirmationTextFromTextInputLayoutThrowsException() { - when(mMockConfirmationTextInputLayout.getEditText()).thenReturn(null); - mValidationHolderConfirmationTypeWithTextInputLayout.getConfirmationText(); - } - - public void testGetConfirmationTextReturnsNull() { - assertNull(mValidationHolderRegexTypeWithEditText.getConfirmationText()); - assertNull(mValidationHolderRangeTypeWithEditText.getConfirmationText()); - assertNull(mValidationHolderSimpleCustomTypeWithEditText.getConfirmationText()); - assertNull(mValidationHolderRegexTypeWithTextInputLayout.getConfirmationText()); - assertNull(mValidationHolderRangeTypeWithTextInputLayout.getConfirmationText()); - assertNull(mValidationHolderSimpleCustomTypeWithTextInputLayout.getConfirmationText()); - assertNull(mValidationHolderCustomTypeWithSomeSortOfView.getConfirmationText()); - } - - public void testGetEditTextFromEditText() { - assertEquals(mMockEditText, mValidationHolderRegexTypeWithEditText.getEditText()); - assertEquals(mMockEditText, mValidationHolderRangeTypeWithEditText.getEditText()); - assertEquals(mMockConfirmationEditText, mValidationHolderConfirmationTypeWithEditText.getEditText()); - assertEquals(mMockEditText, mValidationHolderSimpleCustomTypeWithEditText.getEditText()); - } - - public void testGetEditTextFromTextInputLayout() { - EditText mockEditText = mock(EditText.class); - EditText mockConfirmationEditText = mock(EditText.class); - when(mMockTextInputLayout.getEditText()).thenReturn(mockEditText); - when(mMockConfirmationTextInputLayout.getEditText()).thenReturn(mockConfirmationEditText); - assertEquals(mockEditText, mValidationHolderRegexTypeWithTextInputLayout.getEditText()); - assertEquals(mockEditText, mValidationHolderRangeTypeWithTextInputLayout.getEditText()); - assertEquals(mockConfirmationEditText, mValidationHolderConfirmationTypeWithTextInputLayout.getEditText()); - assertEquals(mockEditText, mValidationHolderSimpleCustomTypeWithTextInputLayout.getEditText()); - } - - public void testGetTextInputLayout() { - assertEquals(mMockTextInputLayout, mValidationHolderRegexTypeWithTextInputLayout.getTextInputLayout()); - assertEquals(mMockTextInputLayout, mValidationHolderRangeTypeWithTextInputLayout.getTextInputLayout()); - assertEquals(mMockConfirmationTextInputLayout, mValidationHolderConfirmationTypeWithTextInputLayout.getTextInputLayout()); - assertEquals(mMockTextInputLayout, mValidationHolderSimpleCustomTypeWithTextInputLayout.getTextInputLayout()); - } - - public void testGetTextInputLayoutReturnsNull() { - assertNull(mValidationHolderRegexTypeWithEditText.getTextInputLayout()); - assertNull(mValidationHolderRangeTypeWithEditText.getTextInputLayout()); - assertNull(mValidationHolderConfirmationTypeWithEditText.getTextInputLayout()); - assertNull(mValidationHolderSimpleCustomTypeWithEditText.getTextInputLayout()); - assertNull(mValidationHolderCustomTypeWithSomeSortOfView.getTextInputLayout()); - } - - public void testGetView() { - assertEquals(mMockView, mValidationHolderCustomTypeWithSomeSortOfView.getView()); - } - - public void testGetViewReturnsNull() { - assertNull(mValidationHolderRegexTypeWithEditText.getView()); - assertNull(mValidationHolderRangeTypeWithEditText.getView()); - assertNull(mValidationHolderConfirmationTypeWithEditText.getView()); - assertNull(mValidationHolderSimpleCustomTypeWithEditText.getView()); - assertNull(mValidationHolderRegexTypeWithTextInputLayout.getView()); - assertNull(mValidationHolderRangeTypeWithTextInputLayout.getView()); - assertNull(mValidationHolderConfirmationTypeWithTextInputLayout.getView()); - assertNull(mValidationHolderSimpleCustomTypeWithTextInputLayout.getView()); - } - - public void testIsVisibleTrue() { - when(mMockEditText.getVisibility()).thenReturn(View.VISIBLE); - when(mMockTextInputLayout.getVisibility()).thenReturn(View.VISIBLE); - when(mMockView.getVisibility()).thenReturn(View.VISIBLE); - assertTrue(mValidationHolderRegexTypeWithEditText.isVisible()); - assertTrue(mValidationHolderRangeTypeWithTextInputLayout.isVisible()); - assertTrue(mValidationHolderCustomTypeWithSomeSortOfView.isVisible()); - } - - public void testIsVisibleFalse() { - when(mMockConfirmationEditText.getVisibility()).thenReturn(View.INVISIBLE); - when(mMockTextInputLayout.getVisibility()).thenReturn(View.GONE); - when(mMockView.getVisibility()).thenReturn(View.INVISIBLE); - assertFalse(mValidationHolderConfirmationTypeWithEditText.isVisible()); - assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isVisible()); - assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isVisible()); - } - - public void testResetCustomError() { - mValidationHolderCustomTypeWithSomeSortOfView.resetCustomError(); - verify(mMockCustomErrorReset, times(1)).reset(mValidationHolderCustomTypeWithSomeSortOfView); - } - -} \ No newline at end of file diff --git a/library/src/test/java/com/basgeekball/awesomevalidation/ValidationHolderTest.kt b/library/src/test/java/com/basgeekball/awesomevalidation/ValidationHolderTest.kt new file mode 100644 index 0000000..01b9ee2 --- /dev/null +++ b/library/src/test/java/com/basgeekball/awesomevalidation/ValidationHolderTest.kt @@ -0,0 +1,334 @@ +package com.basgeekball.awesomevalidation + +import android.support.design.widget.TextInputLayout +import android.text.Editable +import android.view.View +import android.widget.EditText +import com.basgeekball.awesomevalidation.exception.BadLayoutException +import com.basgeekball.awesomevalidation.model.NumericRange +import com.basgeekball.awesomevalidation.utility.custom.CustomErrorReset +import com.basgeekball.awesomevalidation.utility.custom.CustomValidation +import com.basgeekball.awesomevalidation.utility.custom.CustomValidationCallback +import com.basgeekball.awesomevalidation.utility.custom.SimpleCustomValidation +import com.nhaarman.mockitokotlin2.mock +import junit.framework.TestCase +import org.junit.Test +import org.junit.runner.RunWith +import org.mockito.Mockito.* +import org.powermock.api.easymock.PowerMock +import org.powermock.core.classloader.annotations.PrepareForTest +import org.powermock.modules.junit4.PowerMockRunner +import java.util.regex.Pattern + +@RunWith(PowerMockRunner::class) +@PrepareForTest(ValidationHolder::class) +class ValidationHolderTest : TestCase() { + + private lateinit var mMockEditText: EditText + private lateinit var mMockConfirmationEditText: EditText + private lateinit var mMockTextInputLayout: TextInputLayout + private lateinit var mMockConfirmationTextInputLayout: TextInputLayout + private lateinit var mMockView: View + private lateinit var mMockCustomErrorReset: CustomErrorReset + private lateinit var mValidationHolderRegexTypeWithEditText: ValidationHolder + private lateinit var mValidationHolderRangeTypeWithEditText: ValidationHolder + private lateinit var mValidationHolderConfirmationTypeWithEditText: ValidationHolder + private lateinit var mValidationHolderSimpleCustomTypeWithEditText: ValidationHolder + private lateinit var mValidationHolderRegexTypeWithTextInputLayout: ValidationHolder + private lateinit var mValidationHolderRangeTypeWithTextInputLayout: ValidationHolder + private lateinit var mValidationHolderConfirmationTypeWithTextInputLayout: ValidationHolder + private lateinit var mValidationHolderSimpleCustomTypeWithTextInputLayout: ValidationHolder + private lateinit var mValidationHolderCustomTypeWithSomeSortOfView: ValidationHolder + + @Throws(Exception::class) + override fun setUp() { + super.setUp() + mMockEditText = mock() + mMockConfirmationEditText = mock() + mMockTextInputLayout = mock() + mMockConfirmationTextInputLayout = mock() + mMockView = mock() + val mockPattern = PowerMock.createMock(Pattern::class.java) + val mockNumericRange = mock() + val mockSimpleCustomValidation = mock() + val mockCustomValidation = mock() + val mockCustomValidationCallback = mock() + mMockCustomErrorReset = mock() + val mockErrMsg = PowerMock.createMock(String::class.java) + mValidationHolderRegexTypeWithEditText = ValidationHolder(mMockEditText, mockPattern, mockErrMsg) + mValidationHolderRangeTypeWithEditText = ValidationHolder(mMockEditText, mockNumericRange, mockErrMsg) + mValidationHolderConfirmationTypeWithEditText = ValidationHolder(mMockConfirmationEditText, mMockEditText, mockErrMsg) + mValidationHolderSimpleCustomTypeWithEditText = ValidationHolder(mMockEditText, mockSimpleCustomValidation, mockErrMsg) + mValidationHolderRegexTypeWithTextInputLayout = ValidationHolder(mMockTextInputLayout, mockPattern, mockErrMsg) + mValidationHolderRangeTypeWithTextInputLayout = ValidationHolder(mMockTextInputLayout, mockNumericRange, mockErrMsg) + mValidationHolderConfirmationTypeWithTextInputLayout = ValidationHolder(mMockConfirmationTextInputLayout, mMockTextInputLayout, mockErrMsg) + mValidationHolderSimpleCustomTypeWithTextInputLayout = ValidationHolder(mMockTextInputLayout, mockSimpleCustomValidation, mockErrMsg) + mValidationHolderCustomTypeWithSomeSortOfView = ValidationHolder(mMockView, mockCustomValidation, mockCustomValidationCallback, mMockCustomErrorReset, mockErrMsg) + } + + fun testIsRegexTypeTrue() { + assertTrue(mValidationHolderRegexTypeWithEditText.isRegexType) + assertTrue(mValidationHolderRegexTypeWithTextInputLayout.isRegexType) + } + + fun testIsRegexTypeFalse() { + assertFalse(mValidationHolderRangeTypeWithEditText.isRegexType) + assertFalse(mValidationHolderConfirmationTypeWithEditText.isRegexType) + assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isRegexType) + assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isRegexType) + assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isRegexType) + assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isRegexType) + assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isRegexType) + } + + fun testIsRangeTypeTrue() { + assertTrue(mValidationHolderRangeTypeWithEditText.isRangeType) + assertTrue(mValidationHolderRangeTypeWithTextInputLayout.isRangeType) + } + + fun testIsRangeTypeFalse() { + assertFalse(mValidationHolderRegexTypeWithEditText.isRangeType) + assertFalse(mValidationHolderConfirmationTypeWithEditText.isRangeType) + assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isRangeType) + assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isRangeType) + assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isRangeType) + assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isRangeType) + assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isRangeType) + } + + fun testIsConfirmationTypeTrue() { + assertTrue(mValidationHolderConfirmationTypeWithEditText.isConfirmationType) + assertTrue(mValidationHolderConfirmationTypeWithTextInputLayout.isConfirmationType) + } + + fun testIsConfirmationTypeFalse() { + assertFalse(mValidationHolderRegexTypeWithEditText.isConfirmationType) + assertFalse(mValidationHolderRangeTypeWithEditText.isConfirmationType) + assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isConfirmationType) + assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isConfirmationType) + assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isConfirmationType) + assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isConfirmationType) + assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isConfirmationType) + } + + fun testIsSimpleCustomTypeTrue() { + assertTrue(mValidationHolderSimpleCustomTypeWithEditText.isSimpleCustomType) + assertTrue(mValidationHolderSimpleCustomTypeWithTextInputLayout.isSimpleCustomType) + } + + fun testIsSimpleCustomTypeFalse() { + assertFalse(mValidationHolderRegexTypeWithEditText.isSimpleCustomType) + assertFalse(mValidationHolderRangeTypeWithEditText.isSimpleCustomType) + assertFalse(mValidationHolderConfirmationTypeWithEditText.isSimpleCustomType) + assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isSimpleCustomType) + assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isSimpleCustomType) + assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isSimpleCustomType) + assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isSimpleCustomType) + } + + fun testIsCustomTypeTrue() { + assertTrue(mValidationHolderCustomTypeWithSomeSortOfView.isCustomType) + } + + fun testIsCustomTypeFalse() { + assertFalse(mValidationHolderRegexTypeWithEditText.isCustomType) + assertFalse(mValidationHolderRangeTypeWithEditText.isCustomType) + assertFalse(mValidationHolderConfirmationTypeWithEditText.isCustomType) + assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isCustomType) + assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isCustomType) + assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isCustomType) + assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isCustomType) + assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isCustomType) + } + + fun testIsEditTextViewTrue() { + assertTrue(mValidationHolderRegexTypeWithEditText.isEditTextView) + assertTrue(mValidationHolderRangeTypeWithEditText.isEditTextView) + assertTrue(mValidationHolderConfirmationTypeWithEditText.isEditTextView) + assertTrue(mValidationHolderSimpleCustomTypeWithEditText.isEditTextView) + } + + fun testIsEditTextViewFalse() { + assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isEditTextView) + assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isEditTextView) + assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isEditTextView) + assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isEditTextView) + assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isEditTextView) + } + + fun testIsTextInputLayoutViewTrue() { + assertTrue(mValidationHolderRegexTypeWithTextInputLayout.isTextInputLayoutView) + assertTrue(mValidationHolderRangeTypeWithTextInputLayout.isTextInputLayoutView) + assertTrue(mValidationHolderConfirmationTypeWithTextInputLayout.isTextInputLayoutView) + assertTrue(mValidationHolderSimpleCustomTypeWithTextInputLayout.isTextInputLayoutView) + } + + fun testIsTextInputLayoutViewFalse() { + assertFalse(mValidationHolderRegexTypeWithEditText.isTextInputLayoutView) + assertFalse(mValidationHolderRangeTypeWithEditText.isTextInputLayoutView) + assertFalse(mValidationHolderConfirmationTypeWithEditText.isTextInputLayoutView) + assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isTextInputLayoutView) + assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isTextInputLayoutView) + } + + fun testIsSomeSortOfViewTrue() { + assertTrue(mValidationHolderCustomTypeWithSomeSortOfView.isSomeSortOfView) + } + + fun testIsSomeSortOfViewFalse() { + assertFalse(mValidationHolderRegexTypeWithEditText.isSomeSortOfView) + assertFalse(mValidationHolderRangeTypeWithEditText.isSomeSortOfView) + assertFalse(mValidationHolderConfirmationTypeWithEditText.isSomeSortOfView) + assertFalse(mValidationHolderSimpleCustomTypeWithEditText.isSomeSortOfView) + assertFalse(mValidationHolderRegexTypeWithTextInputLayout.isSomeSortOfView) + assertFalse(mValidationHolderRangeTypeWithTextInputLayout.isSomeSortOfView) + assertFalse(mValidationHolderConfirmationTypeWithTextInputLayout.isSomeSortOfView) + assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isSomeSortOfView) + } + + fun testGetTextFromEditText() { + val text = "OK" + val mockEditable = mock() + `when`(mMockEditText.text).thenReturn(mockEditable) + `when`(mockEditable.toString()).thenReturn(text) + assertEquals(text, mValidationHolderRegexTypeWithEditText.text) + assertEquals(text, mValidationHolderRangeTypeWithEditText.text) + assertEquals(text, mValidationHolderConfirmationTypeWithEditText.text) + assertEquals(text, mValidationHolderSimpleCustomTypeWithEditText.text) + } + + fun testGetTextFromTextInputLayout() { + val text = "OK" + val mockEditText = mock() + val mockEditable = mock() + `when`(mMockTextInputLayout.editText).thenReturn(mockEditText) + `when`(mockEditText.text).thenReturn(mockEditable) + `when`(mockEditable.toString()).thenReturn(text) + assertEquals(text, mValidationHolderRegexTypeWithTextInputLayout.text) + assertEquals(text, mValidationHolderRangeTypeWithTextInputLayout.text) + assertEquals(text, mValidationHolderConfirmationTypeWithTextInputLayout.text) + assertEquals(text, mValidationHolderSimpleCustomTypeWithTextInputLayout.text) + } + + @Test(expected = BadLayoutException::class) + fun testGetTextFromTextInputLayoutThrowsException() { + `when`(mMockTextInputLayout.editText).thenReturn(null) + mValidationHolderRegexTypeWithTextInputLayout.text + } + + fun testGetTextReturnsNull() { + val mockEditText: EditText? = null + val mockTextInputLayout: TextInputLayout? = null + val mockPattern = PowerMock.createMock(Pattern::class.java) + val mockErrMsg = PowerMock.createMock(String::class.java) + mValidationHolderRegexTypeWithEditText = ValidationHolder(mockEditText, mockPattern, mockErrMsg) + mValidationHolderRegexTypeWithTextInputLayout = ValidationHolder(mockTextInputLayout, mockPattern, mockErrMsg) + assertNull(mValidationHolderRegexTypeWithEditText.text) + assertNull(mValidationHolderRegexTypeWithTextInputLayout.text) + } + + fun testGetConfirmationTextFromEditText() { + val text = "OK" + val mockEditable = mock() + `when`(mMockConfirmationEditText.text).thenReturn(mockEditable) + `when`(mockEditable.toString()).thenReturn(text) + assertEquals(text, mValidationHolderConfirmationTypeWithEditText.confirmationText) + } + + fun testGetConfirmationTextFromTextInputLayout() { + val text = "OK" + val mockEditText = mock() + val mockEditable = mock() + `when`(mMockConfirmationTextInputLayout.editText).thenReturn(mockEditText) + `when`(mockEditText.text).thenReturn(mockEditable) + `when`(mockEditable.toString()).thenReturn(text) + assertEquals(text, mValidationHolderConfirmationTypeWithTextInputLayout.confirmationText) + } + + @Test(expected = BadLayoutException::class) + fun testGetConfirmationTextFromTextInputLayoutThrowsException() { + `when`(mMockConfirmationTextInputLayout.editText).thenReturn(null) + mValidationHolderConfirmationTypeWithTextInputLayout.confirmationText + } + + fun testGetConfirmationTextReturnsNull() { + assertNull(mValidationHolderRegexTypeWithEditText.confirmationText) + assertNull(mValidationHolderRangeTypeWithEditText.confirmationText) + assertNull(mValidationHolderSimpleCustomTypeWithEditText.confirmationText) + assertNull(mValidationHolderRegexTypeWithTextInputLayout.confirmationText) + assertNull(mValidationHolderRangeTypeWithTextInputLayout.confirmationText) + assertNull(mValidationHolderSimpleCustomTypeWithTextInputLayout.confirmationText) + assertNull(mValidationHolderCustomTypeWithSomeSortOfView.confirmationText) + } + + fun testGetEditTextFromEditText() { + assertEquals(mMockEditText, mValidationHolderRegexTypeWithEditText.editText) + assertEquals(mMockEditText, mValidationHolderRangeTypeWithEditText.editText) + assertEquals(mMockConfirmationEditText, mValidationHolderConfirmationTypeWithEditText.editText) + assertEquals(mMockEditText, mValidationHolderSimpleCustomTypeWithEditText.editText) + } + + fun testGetEditTextFromTextInputLayout() { + val mockEditText = mock() + val mockConfirmationEditText = mock() + `when`(mMockTextInputLayout.editText).thenReturn(mockEditText) + `when`(mMockConfirmationTextInputLayout.editText).thenReturn(mockConfirmationEditText) + assertEquals(mockEditText, mValidationHolderRegexTypeWithTextInputLayout.editText) + assertEquals(mockEditText, mValidationHolderRangeTypeWithTextInputLayout.editText) + assertEquals(mockConfirmationEditText, mValidationHolderConfirmationTypeWithTextInputLayout.editText) + assertEquals(mockEditText, mValidationHolderSimpleCustomTypeWithTextInputLayout.editText) + } + + fun testGetTextInputLayout() { + assertEquals(mMockTextInputLayout, mValidationHolderRegexTypeWithTextInputLayout.textInputLayout) + assertEquals(mMockTextInputLayout, mValidationHolderRangeTypeWithTextInputLayout.textInputLayout) + assertEquals(mMockConfirmationTextInputLayout, mValidationHolderConfirmationTypeWithTextInputLayout.textInputLayout) + assertEquals(mMockTextInputLayout, mValidationHolderSimpleCustomTypeWithTextInputLayout.textInputLayout) + } + + fun testGetTextInputLayoutReturnsNull() { + assertNull(mValidationHolderRegexTypeWithEditText.textInputLayout) + assertNull(mValidationHolderRangeTypeWithEditText.textInputLayout) + assertNull(mValidationHolderConfirmationTypeWithEditText.textInputLayout) + assertNull(mValidationHolderSimpleCustomTypeWithEditText.textInputLayout) + assertNull(mValidationHolderCustomTypeWithSomeSortOfView.textInputLayout) + } + + fun testGetView() { + assertEquals(mMockView, mValidationHolderCustomTypeWithSomeSortOfView.view) + } + + fun testGetViewReturnsNull() { + assertNull(mValidationHolderRegexTypeWithEditText.view) + assertNull(mValidationHolderRangeTypeWithEditText.view) + assertNull(mValidationHolderConfirmationTypeWithEditText.view) + assertNull(mValidationHolderSimpleCustomTypeWithEditText.view) + assertNull(mValidationHolderRegexTypeWithTextInputLayout.view) + assertNull(mValidationHolderRangeTypeWithTextInputLayout.view) + assertNull(mValidationHolderConfirmationTypeWithTextInputLayout.view) + assertNull(mValidationHolderSimpleCustomTypeWithTextInputLayout.view) + } + + fun testIsVisibleTrue() { + `when`(mMockEditText.visibility).thenReturn(View.VISIBLE) + `when`(mMockTextInputLayout.visibility).thenReturn(View.VISIBLE) + `when`(mMockView.visibility).thenReturn(View.VISIBLE) + assertTrue(mValidationHolderRegexTypeWithEditText.isVisible) + assertTrue(mValidationHolderRangeTypeWithTextInputLayout.isVisible) + assertTrue(mValidationHolderCustomTypeWithSomeSortOfView.isVisible) + } + + fun testIsVisibleFalse() { + `when`(mMockConfirmationEditText.visibility).thenReturn(View.INVISIBLE) + `when`(mMockTextInputLayout.visibility).thenReturn(View.GONE) + `when`(mMockView.visibility).thenReturn(View.INVISIBLE) + assertFalse(mValidationHolderConfirmationTypeWithEditText.isVisible) + assertFalse(mValidationHolderSimpleCustomTypeWithTextInputLayout.isVisible) + assertFalse(mValidationHolderCustomTypeWithSomeSortOfView.isVisible) + } + + fun testResetCustomError() { + mValidationHolderCustomTypeWithSomeSortOfView.resetCustomError() + verify(mMockCustomErrorReset, times(1)).reset(mValidationHolderCustomTypeWithSomeSortOfView) + } +} \ No newline at end of file diff --git a/library/src/test/java/com/basgeekball/awesomevalidation/ValidationStyleTest.java b/library/src/test/java/com/basgeekball/awesomevalidation/ValidationStyleTest.java deleted file mode 100644 index 4f7331e..0000000 --- a/library/src/test/java/com/basgeekball/awesomevalidation/ValidationStyleTest.java +++ /dev/null @@ -1,33 +0,0 @@ -package com.basgeekball.awesomevalidation; - -import junit.framework.TestCase; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -@RunWith(JUnit4.class) -public class ValidationStyleTest extends TestCase { - - public void testFromValueToBasic() { - assertEquals(ValidationStyle.BASIC, ValidationStyle.fromValue(0)); - } - - public void testFromValueToColoration() { - assertEquals(ValidationStyle.COLORATION, ValidationStyle.fromValue(1)); - } - - public void testFromValueToUnderlabel() { - assertEquals(ValidationStyle.UNDERLABEL, ValidationStyle.fromValue(2)); - } - - public void testFromValueToTextInputLayout() { - assertEquals(ValidationStyle.TEXT_INPUT_LAYOUT, ValidationStyle.fromValue(3)); - } - - @Test(expected = IllegalArgumentException.class) - public void testFromValueThrowException() { - ValidationStyle.fromValue(4); - } - -} diff --git a/library/src/test/java/com/basgeekball/awesomevalidation/ValidationStyleTest.kt b/library/src/test/java/com/basgeekball/awesomevalidation/ValidationStyleTest.kt new file mode 100644 index 0000000..fce3764 --- /dev/null +++ b/library/src/test/java/com/basgeekball/awesomevalidation/ValidationStyleTest.kt @@ -0,0 +1,36 @@ +package com.basgeekball.awesomevalidation + +import junit.framework.TestCase + +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 + +@RunWith(JUnit4::class) +class ValidationStyleTest : TestCase() { + + @Test + fun testFromValueToBasic() { + assertEquals(ValidationStyle.BASIC, ValidationStyle.fromValue(0)) + } + + @Test + fun testFromValueToColoration() { + assertEquals(ValidationStyle.COLORATION, ValidationStyle.fromValue(1)) + } + + @Test + fun testFromValueToUnderlabel() { + assertEquals(ValidationStyle.UNDERLABEL, ValidationStyle.fromValue(2)) + } + + @Test + fun testFromValueToTextInputLayout() { + assertEquals(ValidationStyle.TEXT_INPUT_LAYOUT, ValidationStyle.fromValue(3)) + } + + @Test(expected = IllegalArgumentException::class) + fun testFromValueThrowException() { + ValidationStyle.fromValue(4) + } +}