Rename encrypt to sign fucntion

Author: haldarmahesh

lib/cipher.dart

@@ -26,18 +26,18 @@ class Cipher {
     }
   }
 
-  /// encrypt the data using the private key from keystore
-  static Future<String> encrypt(String plainData) async {
-    const String encryptTag = 'ENCRYPT';
+  /// sign the data using the private key from keystore
+  static Future<String> sign(String plainData) async {
+    const String signTag = 'SIGN';
     try {
-      final String encryptedData = await _channel.invokeMethod(
+      final String signedData = await _channel.invokeMethod(
           describeEnum(CallMethodType.encrypt), plainData);
-      final formatedEncryptedData = CipherUtils.removeNewLines(encryptedData);
-      return formatedEncryptedData;
+      final formatedSignedData = CipherUtils.removeNewLines(signedData);
+      return formatedSignedData;
     } catch (exception) {
       throw PlatformException(
-          code: '$_packageTag:$encryptTag',
-          message: ExceptionMessageConstant.encryptionFailed,
+          code: '$_packageTag:$signTag',
+          message: ExceptionMessageConstant.signingFailed,
           details: exception);
     }
   }

lib/exception_message_constant.dart

@@ -1,5 +1,5 @@
 class ExceptionMessageConstant {
-  static const encryptionFailed = 'Could not encrypt the data';
+  static const signingFailed = 'Could not sign the data with private key';
   static const verificationFailed =
       'Could not verify the plainText against signature';
   static const getPublicKeyFailed =

test/cipher_test.dart

@@ -7,7 +7,7 @@ void main() {
   TestWidgetsFlutterBinding.ensureInitialized();
 
   String defaultPublicKey = 'PUBLIC_KEY';
-  String defaultEncrptedValue = 'ENCRYPTED-XX';
+  String defaultEncrptedValue = 'SIGNED-XX';
   group(
     'Cipher',
     () {
@@ -61,29 +61,29 @@ void main() {
           });
 
           test(
-            'should return a valid encrypted data from platform',
+            'should return a valid signed data from platform',
             () async {
               // when
-              final String encrypted = await Cipher.encrypt('some  data');
+              final String signed = await Cipher.sign('some  data');
 
               // then
-              expect(encrypted, 'ENCRYPTED-XX');
+              expect(signed, 'SIGNED-XX');
             },
           );
 
           test(
             'should return single line value when multiline value is returned',
             () async {
               // given
-              defaultEncrptedValue = 'encryptedLine1'
-                  'encryptedLine2\nencryptedLine3';
+              defaultEncrptedValue = 'signedLine1'
+                  'signedLine2\nsignedLine3';
               expect(defaultPublicKey.contains('\n'), true);
 
               // when
-              final String encrypted = await Cipher.encrypt('some  data');
+              final String signed = await Cipher.sign('some  data');
 
               // then
-              expect(encrypted, 'encryptedLine1encryptedLine2encryptedLine3');
+              expect(signed, 'signedLine1signedLine2signedLine3');
             },
           );
           test(
@@ -108,7 +108,7 @@ void main() {
                 (MethodCall methodCall) async {
                   if (methodCall.method == 'getPublicKey') {
                     throw Exception('Error getting public key');
-                  } else if (methodCall.method == 'encrypt') {
+                  } else if (methodCall.method == 'sign') {
                     throw Exception('Error getting public key');
                   } else if (methodCall.method == 'verify') {
                     throw Exception('Error in verifying');
@@ -135,17 +135,17 @@ void main() {
           );
 
           test(
-            'should throw exception when platform cannot encrypt data',
+            'should throw exception when platform cannot sign data',
             () async {
               try {
                 // when
-                await Cipher.encrypt(null);
+                await Cipher.sign(null);
               } catch (exception) {
                 // then
                 expect(exception.runtimeType, PlatformException);
-                expect(exception.code, 'CIPHER:ENCRYPT');
+                expect(exception.code, 'CIPHER:SIGN');
                 expect(exception.message,
-                    ExceptionMessageConstant.encryptionFailed);
+                    ExceptionMessageConstant.signingFailed);
               }
             },
           );
@@ -164,7 +164,7 @@ void main() {
               }
             },
           );
-        },
+        }
       );
     },
   );