provisioning_sdk_source/provisioning_sdk/public/python/init_engine_test.py

################################################################################
# Copyright 2016 Google Inc.
#
# This software is licensed under the terms defined in the Widevine Master
# License Agreement. For a copy of this agreement, please contact
# widevine-licensing@google.com.
################################################################################

import unittest

import pywrapcertificate_type
import pywrapprovisioning_engine
import pywrapprovisioning_status
import test_data_utility


class InitEngineTest(unittest.TestCase):

  def setUp(self):
    self._engine = pywrapprovisioning_engine.ProvisioningEngine()

  def testInitEngineSucceed(self):
    test_data_utility.InitProvisionEngineWithTestData(
        self._engine, verify_success=True)

  def testSetCertificateStatusListWithoutInit(self):
    status = self._engine.SetCertificateStatusList('CERTIFICATE_STATUS_LIST',
                                                   3600)
    self.assertEqual(
        pywrapprovisioning_status.PROVISIONING_ENGINE_UNINITIALIZED, status)

  def testGenerateDrmIntermediateCertificateWithoutInit(self):
    status, _ = self._engine.GenerateDrmIntermediateCertificate(
        100, 'INTERMEDIATE_PUBLIC_KEY')
    self.assertEqual(
        pywrapprovisioning_status.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)

  def testGenerateDeviceDrmCertificateWithoutInit(self):
    status, _ = self._engine.GenerateDeviceDrmCertificate(
        100, 'DEVICE_PUBLIC_KEY', 'DEVICE_SERIAL_NUMBER')
    self.assertEqual(
        pywrapprovisioning_status.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)
    self.assertIsNone(session)

  def testInitEngineInvalidServiceDrmCert(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting, 'INVALID_CERT',
        test_data_utility.SERVICE_PRIVATE_KEY,
        test_data_utility.SERVICE_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_DRM_CERT,
        test_data_utility.PROVISIONER_PRIVATE_KEY,
        test_data_utility.PROVISIONER_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_SPOID_SECRET)
    self.assertEqual(pywrapprovisioning_status.INVALID_SERVICE_DRM_CERTIFICATE,
                     status)

  def testInitEngineInvalidServicePrivateKey(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting,
        test_data_utility.SERVICE_DRM_CERT, 'INVALID_KEY',
        test_data_utility.SERVICE_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_DRM_CERT,
        test_data_utility.PROVISIONER_PRIVATE_KEY,
        test_data_utility.PROVISIONER_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_SPOID_SECRET)
    self.assertEqual(pywrapprovisioning_status.INVALID_SERVICE_PRIVATE_KEY,
                     status)

  def testInitEngineWrongServicePrivateKey(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting,
        test_data_utility.SERVICE_DRM_CERT,
        test_data_utility.PROVISIONER_PRIVATE_KEY,
        test_data_utility.SERVICE_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_DRM_CERT,
        test_data_utility.PROVISIONER_PRIVATE_KEY,
        test_data_utility.PROVISIONER_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_SPOID_SECRET)
    self.assertEqual(pywrapprovisioning_status.INVALID_SERVICE_PRIVATE_KEY,
                     status)

  def testInitEngineInvalidServicePrivateKeyPassphrase(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting,
        test_data_utility.SERVICE_DRM_CERT,
        test_data_utility.SERVICE_PRIVATE_KEY, 'INVALID_PASSPHRASE',
        test_data_utility.PROVISIONER_DRM_CERT,
        test_data_utility.PROVISIONER_PRIVATE_KEY,
        test_data_utility.PROVISIONER_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_SPOID_SECRET)
    self.assertEqual(pywrapprovisioning_status.INVALID_SERVICE_PRIVATE_KEY,
                     status)

  def testInitEngineInvalidDrmCert(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting,
        test_data_utility.SERVICE_DRM_CERT,
        test_data_utility.SERVICE_PRIVATE_KEY,
        test_data_utility.SERVICE_PRIVATE_KEY_PASS, 'INVALID_CERT',
        test_data_utility.PROVISIONER_PRIVATE_KEY,
        test_data_utility.PROVISIONER_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_SPOID_SECRET)
    self.assertEqual(
        pywrapprovisioning_status.INVALID_PROVISIONER_DRM_CERTIFICATE, status)

  def testInitEngineInvalidDrmPrivateKey(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting,
        test_data_utility.SERVICE_DRM_CERT,
        test_data_utility.SERVICE_PRIVATE_KEY,
        test_data_utility.SERVICE_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_DRM_CERT, 'INVALID_KEY',
        test_data_utility.PROVISIONER_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_SPOID_SECRET)
    self.assertEqual(pywrapprovisioning_status.INVALID_PROVISIONER_PRIVATE_KEY,
                     status)

  def testInitEngineWrongDrmPrivateKey(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting,
        test_data_utility.SERVICE_DRM_CERT,
        test_data_utility.SERVICE_PRIVATE_KEY,
        test_data_utility.SERVICE_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_DRM_CERT,
        test_data_utility.SERVICE_PRIVATE_KEY,
        test_data_utility.PROVISIONER_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_SPOID_SECRET)
    self.assertEqual(pywrapprovisioning_status.INVALID_PROVISIONER_PRIVATE_KEY,
                     status)

  def testInitEngineInvalidDrmPrivateKeyPassphrase(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting,
        test_data_utility.SERVICE_DRM_CERT,
        test_data_utility.SERVICE_PRIVATE_KEY,
        test_data_utility.SERVICE_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_DRM_CERT,
        test_data_utility.PROVISIONER_PRIVATE_KEY,
        'INVALID_PASSPHRASE',
        test_data_utility.PROVISIONER_SPOID_SECRET)
    self.assertEqual(pywrapprovisioning_status.INVALID_PROVISIONER_PRIVATE_KEY,
                     status)

  def testInitEngineInvalidSpoidSecret(self):
    status = self._engine.Initialize(
        pywrapcertificate_type.kCertTesting,
        test_data_utility.SERVICE_DRM_CERT,
        test_data_utility.SERVICE_PRIVATE_KEY,
        test_data_utility.SERVICE_PRIVATE_KEY_PASS,
        test_data_utility.PROVISIONER_DRM_CERT,
        test_data_utility.PROVISIONER_PRIVATE_KEY,
        test_data_utility.PROVISIONER_PRIVATE_KEY_PASS,
        '')
    self.assertEqual(pywrapprovisioning_status.INVALID_SPOID_SAUCE, status)

if __name__ == '__main__':
  unittest.main()