def test_hex_encoded_cap(self, urandom): """ generate_capability will hex encode the random bytes from os.urandom. """ urandom.return_value = '\xde\xad\xbe\xef' (_v, cap) = generate_capability() self.assertEqual(cap, 'deadbeef')
def test_hex_encoded_cap(self, urandom): """ generate_capability will hex encode the random bytes from os.urandom. """ urandom.return_value = '\xde\xad\xbe\xef' (_v, cap) = generate_capability() self.assertEqual(cap, 'deadbeef')
def test_urandom_32_bytes(self, urandom): """ generate_capability will use os.urandom to get 32 bytes of random data. """ (_v, _cap) = generate_capability() urandom.assert_called_once_with(32)
def create_webhooks(self, policy_id, data): """ see :meth:`otter.models.interface.IScalingGroup.create_webhooks` """ if self.error is not None: return defer.fail(self.error) if policy_id in self.policies: max_webhooks = config_value('limits.absolute.maxWebhooksPerPolicy') curr_webhooks = len(self.webhooks.get(policy_id, [])) if len(data) + curr_webhooks > max_webhooks: return defer.fail( WebhooksOverLimitError(self.tenant_id, self.uuid, policy_id, max_webhooks, curr_webhooks, len(data))) created = [] for webhook_input in data: webhook_real = {'metadata': {}} webhook_real.update(webhook_input) webhook_real['capability'] = {} (webhook_real['capability']['version'], webhook_real['capability']['hash']) = generate_capability() uuid = str(uuid4()) self.webhooks[policy_id][uuid] = webhook_real # return a copy so this store doesn't get mutated created.append(dict(id=uuid, **webhook_real)) return defer.succeed(created) else: return defer.fail(NoSuchPolicyError(self.tenant_id, self.uuid, policy_id))
def test_urandom_32_bytes(self, urandom): """ generate_capability will use os.urandom to get 32 bytes of random data. """ (_v, _cap) = generate_capability() urandom.assert_called_once_with(32)
def create_webhooks(self, policy_id, data): """ see :meth:`otter.models.interface.IScalingGroup.create_webhooks` """ if self.error is not None: return defer.fail(self.error) if policy_id in self.policies: created = {} for webhook_input in data: webhook_real = {'metadata': {}} webhook_real.update(webhook_input) webhook_real['capability'] = {} (webhook_real['capability']['version'], webhook_real['capability']['hash']) = generate_capability() uuid = str(uuid4()) self.webhooks[policy_id][uuid] = webhook_real # return a copy so this store doesn't get mutated created[uuid] = webhook_real.copy() return defer.succeed(created) else: return defer.fail(NoSuchPolicyError(self.tenant_id, self.uuid, policy_id))
def create_webhooks(self, policy_id, data): """ see :meth:`otter.models.interface.IScalingGroup.create_webhooks` """ if self.error is not None: return defer.fail(self.error) if policy_id in self.policies: created = {} for webhook_input in data: webhook_real = {'metadata': {}} webhook_real.update(webhook_input) webhook_real['capability'] = {} (webhook_real['capability']['version'], webhook_real['capability']['hash']) = generate_capability() uuid = str(uuid4()) self.webhooks[policy_id][uuid] = webhook_real # return a copy so this store doesn't get mutated created[uuid] = webhook_real.copy() return defer.succeed(created) else: return defer.fail( NoSuchPolicyError(self.tenant_id, self.uuid, policy_id))
def _build_webhooks(bare_webhooks, webhooks_table, queries, cql_parameters, output): """ Because inserting many values into a table with compound keys with one insert statement is hard. This builds a bunch of insert statements and a dictionary matching different parameter names to different policies. :param bare_webhooks: a list of webhook data without ID or webhook keys, or any generated capability hash info :type bare_webhooks: ``list`` of ``dict`` :param webhooks_table: the name of the webhooks table :type webhooks_table: ``str`` :param queries: a list of existing CQL queries to add to :type queries: ``list`` of ``str`` :param cql_parameters: the dictionary of named parameters and values passed in addition to the query to execute the query - additional parameters will be added to this dictionary :type cql_paramters: ``dict`` :param output: a dictionary to which to insert the created policies along with their generated IDs :type output: ``dict`` """ for i, webhook in enumerate(bare_webhooks): name = "webhook{0}".format(i) webhook_id = generate_key_str('webhook') queries.append(_cql_insert_webhook.format(cf=webhooks_table, name=name)) # generate the real data that will be stored, which includes the webhook # token, the capability stuff, and metadata by default bare_webhooks[i].setdefault('metadata', {}) version, cap_hash = generate_capability() cql_parameters[name] = serialize_json_data(webhook, 1) cql_parameters['{0}Id'.format(name)] = webhook_id cql_parameters['{0}Key'.format(name)] = cap_hash cql_parameters['{0}Capability'.format(name)] = serialize_json_data( {version: cap_hash}, 1) output[webhook_id] = webhook.copy() output[webhook_id]['capability'] = { 'hash': cap_hash, 'version': version }
def _build_webhooks(bare_webhooks, webhooks_table, queries, cql_parameters): """ Because inserting many values into a table with compound keys with one insert statement is hard. This builds a bunch of insert statements and a dictionary matching different parameter names to different policies. :param bare_webhooks: a list of webhook data without ID or webhook keys, or any generated capability hash info :type bare_webhooks: ``list`` of ``dict`` :param webhooks_table: the name of the webhooks table :type webhooks_table: ``str`` :param queries: a list of existing CQL queries to add to :type queries: ``list`` of ``str`` :param cql_parameters: the dictionary of named parameters and values passed in addition to the query to execute the query - additional parameters will be added to this dictionary :type cql_paramters: ``dict`` :returns: ``list`` of the created webhooks along with their IDs """ output = [] for i, webhook in enumerate(bare_webhooks): name = "webhook{0}".format(i) webhook_id = generate_key_str('webhook') queries.append(_cql_insert_webhook.format(cf=webhooks_table, name=name)) # generate the real data that will be stored, which includes the webhook # token, the capability stuff, and metadata by default bare_webhooks[i].setdefault('metadata', {}) version, cap_hash = generate_capability() cql_parameters[name] = serialize_json_data(webhook, 1) cql_parameters['{0}Id'.format(name)] = webhook_id cql_parameters['{0}Key'.format(name)] = cap_hash cql_parameters['{0}Capability'.format(name)] = serialize_json_data( {version: cap_hash}, 1) output.append(dict(id=webhook_id, capability={'hash': cap_hash, 'version': version}, **webhook)) return output
def test_version_1(self): """ generate_capability returns a version 1 capability. """ (v, _cap) = generate_capability() self.assertEqual(v, "1")
def test_version_1(self): """ generate_capability returns a version 1 capability. """ (v, _cap) = generate_capability() self.assertEqual(v, "1")