Refactor and cleanup codes. No functional changes.

provisioning_sdk/public/python/init_engine_test.py

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright 2016 Google Inc.
+# Copyright 2016 Google LLC.
 #
 # This software is licensed under the terms defined in the Widevine Master
 # License Agreement. For a copy of this agreement, please contact
@@ -8,83 +8,85 @@
 
 import unittest
 
-import pywrapcertificate_type
-import pywrapprovisioning_engine
-import pywrapprovisioning_status
+from certificate_type import CertificateType
 import test_data_provider
 import test_data_utility
+from provisioning_engine import ProvisioningEngine
+from provisioning_status import ProvisioningStatus
+from protos.public import certificate_provisioning_pb2
 
 
 class InitEngineTest(unittest.TestCase):
 
   def setUp(self):
-    self._engine = pywrapprovisioning_engine.ProvisioningEngine()
+    self._engine = ProvisioningEngine()
     self._data_provider = test_data_provider.TestDataProvider(
-        pywrapcertificate_type.kCertTesting)
+        CertificateType.kCertificateTypeTesting)
+    self._prov30 = (
+        certificate_provisioning_pb2.SignedProvisioningMessage.PROVISIONING_30)
 
   def testInitEngineSucceed(self):
-    test_data_utility.InitProvisionEngineWithTestData(
+    status = test_data_utility.InitProvisionEngineWithTestData(
         self._engine, verify_success=True)
+    self.assertEqual(ProvisioningStatus.OK, status)
 
   def testSetCertificateStatusListWithoutInit(self):
     status = self._engine.SetCertificateStatusList('CERTIFICATE_STATUS_LIST',
                                                    3600)
-    self.assertEqual(
-        pywrapprovisioning_status.PROVISIONING_ENGINE_UNINITIALIZED, status)
+    self.assertEqual(ProvisioningStatus.PROVISIONING_ENGINE_UNINITIALIZED,
+                     status)
 
   def testGenerateDrmIntermediateCertificateWithoutInit(self):
     status, _ = self._engine.GenerateDrmIntermediateCertificate(
         100, 'INTERMEDIATE_PUBLIC_KEY')
-    self.assertEqual(
-        pywrapprovisioning_status.PROVISIONING_ENGINE_UNINITIALIZED, status)
+    self.assertEqual(ProvisioningStatus.PROVISIONING_ENGINE_UNINITIALIZED,
+                     status)
 
   def testAddDrmIntermediateCertificateWithoutInit(self):
     status = self._engine.AddDrmIntermediateCertificate(
         'INTERMEDIATE_CERTIFICATE', 'INTERMEDIATE_PRIVATE_KEY',
         'INTERMEDIATE_PRIVATE_KEY_PASSPHRASE')
-    self.assertEqual(
-        pywrapprovisioning_status.PROVISIONING_ENGINE_UNINITIALIZED, status)
+    self.assertEqual(ProvisioningStatus.PROVISIONING_ENGINE_UNINITIALIZED,
+                     status)
 
   def testGenerateDeviceDrmCertificateWithoutInit(self):
     status, _ = self._engine.GenerateDeviceDrmCertificate(
         100, 'DEVICE_PUBLIC_KEY', 'DEVICE_SERIAL_NUMBER')
-    self.assertEqual(
-        pywrapprovisioning_status.PROVISIONING_ENGINE_UNINITIALIZED, status)
+    self.assertEqual(ProvisioningStatus.PROVISIONING_ENGINE_UNINITIALIZED,
+                     status)
 
   def testNewProvisioningSessionWithoutInit(self):
-    status, session = self._engine.NewProvisioningSession('DEVICE_PUBLIC_KEY',
-                                                          'DEVICE_PRIVATE_KEY')
-    self.assertEqual(
-        pywrapprovisioning_status.PROVISIONING_ENGINE_UNINITIALIZED, status)
+    session, status = self._engine.NewProvisioningSession(
+        self._prov30, 'DEVICE_PUBLIC_KEY', 'DEVICE_PRIVATE_KEY')
+    self.assertEqual(ProvisioningStatus.PROVISIONING_ENGINE_UNINITIALIZED,
+                     status)
     self.assertIsNone(session)
 
   def testInitEngineInvalidServiceDrmCert(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting, 'INVALID_CERT',
+        CertificateType.kCertificateTypeTesting, 'INVALID_CERT',
         self._data_provider.service_private_key,
         self._data_provider.service_private_key_passphrase,
         self._data_provider.provisioner_drm_cert,
         self._data_provider.provisioner_private_key,
         self._data_provider.provisioner_private_key_passphrase,
         self._data_provider.provisioner_spoid_secret)
-    self.assertEqual(pywrapprovisioning_status.INVALID_SERVICE_DRM_CERTIFICATE,
-                     status)
+    self.assertEqual(ProvisioningStatus.INVALID_SERVICE_DRM_CERTIFICATE, status)
 
   def testInitEngineInvalidServicePrivateKey(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting,
+        CertificateType.kCertificateTypeTesting,
         self._data_provider.service_drm_cert, 'INVALID_KEY',
         self._data_provider.service_private_key_passphrase,
         self._data_provider.provisioner_drm_cert,
         self._data_provider.provisioner_private_key,
         self._data_provider.provisioner_private_key_passphrase,
         self._data_provider.provisioner_spoid_secret)
-    self.assertEqual(pywrapprovisioning_status.INVALID_SERVICE_PRIVATE_KEY,
-                     status)
+    self.assertEqual(ProvisioningStatus.INVALID_SERVICE_DRM_CERTIFICATE, status)
 
   def testInitEngineWrongServicePrivateKey(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting,
+        CertificateType.kCertificateTypeTesting,
         self._data_provider.service_drm_cert,
         self._data_provider.provisioner_private_key,
         self._data_provider.service_private_key_passphrase,
@@ -92,48 +94,45 @@ class InitEngineTest(unittest.TestCase):
         self._data_provider.provisioner_private_key,
         self._data_provider.provisioner_private_key_passphrase,
         self._data_provider.provisioner_spoid_secret)
-    self.assertEqual(pywrapprovisioning_status.INVALID_SERVICE_PRIVATE_KEY,
-                     status)
+    self.assertEqual(ProvisioningStatus.INVALID_SERVICE_DRM_CERTIFICATE, status)
 
   def testInitEngineInvalidServicePrivateKeyPassphrase(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting,
+        CertificateType.kCertificateTypeTesting,
         self._data_provider.service_drm_cert,
         self._data_provider.service_private_key, 'INVALID_PASSPHRASE',
         self._data_provider.provisioner_drm_cert,
         self._data_provider.provisioner_private_key,
         self._data_provider.provisioner_private_key_passphrase,
         self._data_provider.provisioner_spoid_secret)
-    self.assertEqual(pywrapprovisioning_status.INVALID_SERVICE_PRIVATE_KEY,
-                     status)
+    self.assertEqual(ProvisioningStatus.INVALID_SERVICE_DRM_CERTIFICATE, status)
 
   def testInitEngineInvalidDrmCert(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting,
+        CertificateType.kCertificateTypeTesting,
         self._data_provider.service_drm_cert,
         self._data_provider.service_private_key,
         self._data_provider.service_private_key_passphrase, 'INVALID_CERT',
         self._data_provider.provisioner_private_key,
         self._data_provider.provisioner_private_key_passphrase,
         self._data_provider.provisioner_spoid_secret)
-    self.assertEqual(
-        pywrapprovisioning_status.INVALID_PROVISIONER_DRM_CERTIFICATE, status)
+    self.assertEqual(ProvisioningStatus.INVALID_PROVISIONER_DRM_CERTIFICATE,
+                     status)
 
   def testInitEngineInvalidDrmPrivateKey(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting,
+        CertificateType.kCertificateTypeTesting,
         self._data_provider.service_drm_cert,
         self._data_provider.service_private_key,
         self._data_provider.service_private_key_passphrase,
         self._data_provider.provisioner_drm_cert, 'INVALID_KEY',
         self._data_provider.provisioner_private_key_passphrase,
         self._data_provider.provisioner_spoid_secret)
-    self.assertEqual(pywrapprovisioning_status.INVALID_PROVISIONER_PRIVATE_KEY,
-                     status)
+    self.assertEqual(ProvisioningStatus.INVALID_PROVISIONER_PRIVATE_KEY, status)
 
   def testInitEngineWrongDrmPrivateKey(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting,
+        CertificateType.kCertificateTypeTesting,
         self._data_provider.service_drm_cert,
         self._data_provider.service_private_key,
         self._data_provider.service_private_key_passphrase,
@@ -141,32 +140,30 @@ class InitEngineTest(unittest.TestCase):
         self._data_provider.service_private_key,
         self._data_provider.provisioner_private_key_passphrase,
         self._data_provider.provisioner_spoid_secret)
-    self.assertEqual(pywrapprovisioning_status.INVALID_PROVISIONER_PRIVATE_KEY,
-                     status)
+    self.assertEqual(ProvisioningStatus.INVALID_PROVISIONER_PRIVATE_KEY, status)
 
   def testInitEngineInvalidDrmPrivateKeyPassphrase(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting,
+        CertificateType.kCertificateTypeTesting,
         self._data_provider.service_drm_cert,
         self._data_provider.service_private_key,
         self._data_provider.service_private_key_passphrase,
         self._data_provider.provisioner_drm_cert,
         self._data_provider.provisioner_private_key_passphrase,
-        'INVALID_PASSPHRASE',
-        self._data_provider.provisioner_spoid_secret)
-    self.assertEqual(pywrapprovisioning_status.INVALID_PROVISIONER_PRIVATE_KEY,
-                     status)
+        'INVALID_PASSPHRASE', self._data_provider.provisioner_spoid_secret)
+    self.assertEqual(ProvisioningStatus.INVALID_PROVISIONER_PRIVATE_KEY, status)
 
   def testInitEngineInvalidSpoidSecret(self):
     status = self._engine.Initialize(
-        pywrapcertificate_type.kCertTesting,
+        CertificateType.kCertificateTypeTesting,
         self._data_provider.service_drm_cert,
         self._data_provider.service_private_key,
         self._data_provider.service_private_key_passphrase,
         self._data_provider.provisioner_drm_cert,
         self._data_provider.provisioner_private_key,
         self._data_provider.provisioner_private_key_passphrase, '')
-    self.assertEqual(pywrapprovisioning_status.INVALID_SPOID_SAUCE, status)
+    self.assertEqual(ProvisioningStatus.INVALID_SPOID_SAUCE, status)
+
 
 if __name__ == '__main__':
   unittest.main()