bluetooth: fuzzer: Add a connect and getPrimaryServices tokens

third_party/WebKit/Source/modules/bluetooth/testing/clusterfuzz/constraints.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Module to get random numbers, strings, etc.
 
    The values returned by the various functions can be replaced in
    templates to generate test cases.
 """
 
 import random
 import sys
 import uuid
 
 # This script needs the utils.py and fuzzy_types.py modules in order
 # to work. This files are copied by the setup.py script and not checked-in
 # next to this code, so we need to disable the style warning.
 # pylint: disable=F0401
 from resources import utils
 from resources import fuzzy_types
 
 import gatt_aliases
+import wbt_fakes
 
 
-# List of services that are included in our fake adapters.
-FAKE_SERVICES = [
-    'generic_access',
-    'glucose',
-    'heart_rate',
-    'battery_service',
-    'human_interface_device',
-    '000000a0-97e5-4cd7-b9f1-f5a427670c59',  # Error UUID
-    'device_information',
-    '611c954a-263b-4f4a-aab6-01ddb953f985',  # Blacklisted
-    '01d7d889-7451-419f-aeb8-d65e7b9277af',  # Request Disconnection
-]
+# Strings that are used at the beginning of a test.

[scheib, 2016/07/26 19:04:44]

Comment that these are going to have parameters filled in below, so they have
arguments.
As discussed, 'print' and optionally named parameters may make this code more
readable & reduce errors (parameters must match intention).

print ("setBluetoothFakeAdapter(%(FAKENAME)s) {}" % { 'FAKENAME':'frobber'})

[ortuno, 2016/07/28 22:26:22]

I added names to the parameters but I kept format given the warning on %'s
documentation[1]:

"The formatting operations described here are obsolete and may go away in future
versions of Python. Use the new String Formatting in new code."

[1]
https://docs.python.org/release/3.1.5/library/stdtypes.html#old-string-format...

+BASIC_BASE = \
+    '  return setBluetoothFakeAdapter({})\n'\
+    '    .then(() => {{\n'
 
-# List of available fake adapters.
-FAKE_ADAPTERS = [
-    'BaseAdapter',
-    'NotPresentAdapter',
-    'NotPoweredAdapter',
-    'EmptyAdapter',
-    'FailStartDiscoveryAdapter',
-    'GlucoseHeartRateAdapter',
-    'UnicodeDeviceAdapter',
-    'MissingServiceHeartRateAdapter',
-    'MissingCharacteristicHeartRateAdapter',
-    'HeartRateAdapter',
-    'TwoHeartRateServicesAdapter',
-    'DisconnectingHeartRateAdapter',
-    'BlacklistTestAdapter',
-    'FailingConnectionsAdapter',
-    'FailingGATTOperationsAdapter',
-    'DelayedServicesDiscoveryAdapter',
-]
+DEVICE_DISCOVERY_BASE = BASIC_BASE + \
+    '      return requestDeviceWithKeyDown({{filters: [{{services: [{}]}}]}});\n'\
+    '    }})\n'\
+    '    .then(device => {{\n'
+
+CONNECTABLE_BASE = DEVICE_DISCOVERY_BASE + \
+    '      return device.gatt.connect();\n'\
+    '    }})\n'\
+    '    .then(gatt => {{\n'
+
+SERVICE_RETRIEVED_BASE = CONNECTABLE_BASE + \
+    '      return gatt.getPrimaryService({});\n'\
+    '    }})\n'\
+    '    .then(service => {{\n'
 
 
 def _ToJsStr(s):
     return u'\'{}\''.format(s)
 
 
-def GetFakeAdapter():
-    return _ToJsStr(random.choice(FAKE_ADAPTERS))
+def GetAnyFakeAdapter():
+    """Returns the name of a fake adapter surrounded by quotation marks."""
+    return _ToJsStr(random.choice(wbt_fakes.ALL_ADAPTERS))
+
+
+def GetAdapterWithDevice():
+    """Returns an adapter name and an advertised service in that adapter."""
+    adapter, services = random.choice(wbt_fakes.ADAPTERS_WITH_DEVICES)
+    return _ToJsStr(adapter), _ToJsStr(random.choice(services))
+
+
+def GetAdapterWithServices():
+    """Returns two strings, the adapter name and a service in that adapter."""
+    adapter, services = random.choice(wbt_fakes.ADAPTERS_WITH_SERVICES)
+    return _ToJsStr(adapter), random.choice(services)
 
 
 def _GetFuzzedJsString(s):
     """Returns a fuzzed string based on |s|.
 
     Args:
       s: The base string to fuzz.
     Returns:
       A single line string surrounded by quotes.
     """
     while True:
         fuzzed_string = fuzzy_types.FuzzyString(s)
         try:
             fuzzed_string = fuzzed_string.decode('utf8')
         except UnicodeDecodeError:
             print 'Can\'t decode fuzzed string. Trying again.'
         else:
             fuzzed_string = '\\n'.join(fuzzed_string.split())
             fuzzed_string = fuzzed_string.replace('\'', r'\'')
             return _ToJsStr(fuzzed_string)
 
 
-def GetServiceUUIDFromFakes():
+def GetAdvertisedServiceUUIDFromFakes():
     """Returns a random service string from the list of fake services."""
-    return _ToJsStr(random.choice(FAKE_SERVICES))
+    return _ToJsStr(random.choice(wbt_fakes.ADVERTISED_SERVICES))
 
 
 def GetValidServiceAlias():
     """Returns a valid service alias from the list of services aliases."""
     return _ToJsStr(random.choice(gatt_aliases.SERVICES))
 
 
 def GetRandomUUID():
     """Returns a random UUID, a random number or a fuzzed uuid or alias."""
     choice = random.choice(['uuid', 'number', 'fuzzed string'])
     if choice == 'uuid':
         return _ToJsStr(uuid.uuid4())
     elif choice == 'number':
         return utils.UniformExpoInteger(0, sys.maxsize.bit_length() + 1)
     elif choice == 'fuzzed string':
         choice2 = random.choice(['uuid', 'alias'])
         if choice2 == 'uuid':
             random_uuid = str(uuid.uuid4())
             return _GetFuzzedJsString(random_uuid)
         elif choice2 == 'alias':
             alias = random.choice(gatt_aliases.SERVICES)
             return _GetFuzzedJsString(alias)
 
 
-def GetServiceUUID():
+def GetAdvertisedServiceUUID():
     """Generates a random Service UUID from a set of functions.
 
     See GetServiceUUIDFromFakes(), GetValidServiceAlias() and GetRandomUUID()
     for the different values this function can return.
 
     This function weights GetServiceUUIDFromFakes() more heavily to increase the
     probability of generating test pages that can interact with the fake
     adapters.
 
     Returns:
       A string or a number that can be used as a Service UUID by the Web
       Bluetooth API.
     """
     roll = random.random()
     if roll < 0.8:
-        return GetServiceUUIDFromFakes()
+        return GetAdvertisedServiceUUIDFromFakes()
     elif roll < 0.9:
         return GetValidServiceAlias()
     else:
         return GetRandomUUID()
 
 
 def GetRequestDeviceOptions():
     """Returns an object used by navigator.bluetooth.requestDevice."""
     # TODO(ortuno): Randomize the members, number of filters, services, etc.
 
-    return '{filters: [{services: [ %s ]}]}' % GetServiceUUID()
+    return '{filters: [{services: [ %s ]}]}' % GetAdvertisedServiceUUID()
+
+
+def GetBasicBase():
+    """Returns a string that sets a random fake adapter."""
+    return BASIC_BASE.format(GetAnyFakeAdapter())
+
+
+def GetDeviceDiscoveryBase():
+    """Generates a string that contains all steps to find a device."""
+    return DEVICE_DISCOVERY_BASE.format(*GetAdapterWithDevice())
+
+
+def GetConnectableBase():
+    """Generates a string that contains all steps to connect to a device.
+
+    Returns: A string that:
+      1. Sets an adapter to a fake adapter with a connectable device.
+      2. Looks for the connectable device.
+      3. Connects to it.
+    """
+    return CONNECTABLE_BASE.format(*GetAdapterWithDevice())
+
+
+def GetServiceRetrievedBase():
+    """Returns a string that contains all steps to retrieve a service.
+
+    Returns: A string that:
+      1. Sets an adapter to a fake adapter with a connectable device with
+         services.
+      2. Use one of the device's services to look for that device.
+      3. Connects to it.
+      4. Retrieve the device's service used in 2.
+    """
+    adapter, service = GetAdapterWithServices()
+    return SERVICE_RETRIEVED_BASE.format(adapter, service, service)