def step_impl(context, challenge_id):
    context.json_object = json.loads(context.rv.body)

    assert_that(context.json_object, has_key("error"))
    if context.json_object["error"] is False:
        assert_that(context.json_object, has_key("challenge_id"))
        assert_that(context.json_object["challenge_id"], equal_to(int(challenge_id)))
 def test_mapping_of_piwik_datapoint_keys(self):
     parser = build_parser()
     parsed_data = parser.parse(get_piwik_data())
     assert_that(parsed_data[0], has_key('browser'))
     assert_that(parsed_data[0], has_key('sessions'))
     self.assertFalse('label' in parsed_data[0])
     self.assertFalse('nb_visits' in parsed_data[0])
Exemplo n.º 3
0
    def test_update_instance_flavor_for_terminated_instance(self):
        some_new_flavor = 'some_new_flavor'
        data = dict(flavor=some_new_flavor)
        start = '2016-03-01 00:00:00.000000'
        end = '2016-03-03 00:00:00.000000'

        self.controller.should_receive('update_inactive_entity') \
            .with_args(
                instance_id="INSTANCE_ID",
                start=a_date_matching(start),
                end=a_date_matching(end),
                flavor=some_new_flavor,
        ).and_return(a(
                instance().
                with_id('INSTANCE_ID').
                with_start(2016, 03, 01, 00, 0, 00).
                with_end(2016, 03, 03, 00, 0, 00).
                with_flavor(some_new_flavor))
        )

        code, result = self.api_put(
                '/entity/instance/INSTANCE_ID',
                headers={'X-Auth-Token': 'some token value'},
                query_string={
                    'start': start,
                    'end': end,
                },
                data=data,
        )
        assert_that(code, equal_to(200))
        assert_that(result, has_key('entity_id'))
        assert_that(result, has_key('flavor'))
        assert_that(result['flavor'], is_(some_new_flavor))
Exemplo n.º 4
0
    def test_get(self):
        collector = CollectorFactory()
        response = self.client.get(
            '/collector/{}'.format(collector.slug),
            HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
            content_type='application/json')

        assert_that(response.status_code, equal_to(200))

        resp_json = json.loads(response.content)

        assert_that(resp_json['id'], equal_to(str(collector.id)))
        assert_that(resp_json['slug'], equal_to(collector.slug))
        assert_that(resp_json['name'], equal_to(collector.name))
        assert_that(resp_json['type']['name'], equal_to(
            collector.type.name))
        assert_that(resp_json['type']['slug'], equal_to(
            collector.type.slug))
        assert_that(resp_json['entry_point'], equal_to(
            collector.type.entry_point))
        assert_that(
            resp_json['data_source']['name'], equal_to(
                collector.data_source.name))
        assert_that(resp_json['data_set']['data_type'], equal_to(
            collector.data_set.data_type.name))
        assert_that(resp_json['data_set']['data_group'], equal_to(
            collector.data_set.data_group.name))
        assert_that(resp_json['data_set'], has_key('bearer_token'))
        assert_that(resp_json['query'], equal_to(collector.query))
        assert_that(resp_json['options'], equal_to(collector.options))
        assert_that(resp_json['provider']['slug'], equal_to(
            collector.type.provider.slug))
        assert_that(resp_json['provider']['name'], equal_to(
            collector.type.provider.name))
        assert_that(resp_json, not(has_key('owners')))
Exemplo n.º 5
0
    def test_application_info(self):

        app_info = {
            'text_key': u'a value',
            'byte_key': b'bytes',
            'int_key': 7,
            'list_key': [42,]
        }

        class IA(Interface):

            field = Attribute("A field")
            field.setTaggedValue(jsonschema.TAG_APPLICATION_INFO, app_info)

        schema = TranslateTestSchema(IA, context=u' TEST').make_schema()

        assert_that(schema, has_key("field"))
        field = schema['field']
        assert_that(field, has_key("application_info"))
        # The dict itself was copied
        assert_that(field['application_info'], is_not(same_instance(app_info)))
        # as were its contents
        assert_that(field['application_info'], has_entry('list_key', is_([42])))
        assert_that(field['application_info'],
                    has_entry('list_key', is_not(same_instance(app_info['list_key']))))

        # Text strings were translated
        assert_that(field['application_info'], has_entry('text_key', u'a value TEST'))

        # Byte strings were not (is that even legel in json?)
        assert_that(field['application_info'], has_entry('byte_key', b'bytes'))
Exemplo n.º 6
0
def test_removes_old_ipi_frames(mp3):
    filename = mp3(TXXX_IPI_Joel_Miller="00000123456789",
                   TXXX_IPI_Rebecca_Ann_Maloy="98765432100000")
    container.save(filename, Metadata(ipis={"Joel Miller": "00000123456789"}))

    tags = MP3(filename)
    assert_that(tags, all_of(has_key("TXXX:IPI:Joel Miller"),
                             not_(has_key("TXXX:IPI:Rebecca Ann Maloy"))), "tags in file")
Exemplo n.º 7
0
def step_impl(context):
    context.json_object = json.loads(context.rv.body)

    assert_that(context.json_object, has_key("game"))
    assert_that(context.json_object["game"], has_key(u'original_release_date'))
    assert_that(context.json_object["game"], has_key(u'description'))
    assert_that(context.json_object["game"], has_key(u'image'))
    assert_that(context.json_object["game"], has_key(u'name'))
Exemplo n.º 8
0
    def assert_response_for_list(self, response, expected):
        assert_that(response.status_code, equal_to(200))

        data = self._serialize_decode(response.data)
        assert_that(data, has_key('total'))
        assert_that(data, has_key('items'))

        list_assertion = contains(*(self._build_assertion(i) for i in data['items']))
        assert_that(data['items'], list_assertion)
    def test_dict_should_behave_as_dict(self):
        config = probe(path=_dir("single-file"),
                       patterns=["(*).yaml"])

        assert_that(config["stuff"]["key"], is_("stuff-value"))
        assert_that(dict(config), has_key('stuff'))
        assert_that(dict(**config), has_key('stuff'))
        assert_that(dict(config.stuff), has_key('key'))
        assert_that(dict(**config.stuff), has_key('key'))
Exemplo n.º 10
0
def test_removes_contributor_from_chain_of_title():
    chain_of_title = make_chain_of_title(
        authors_composers=[joel_miller(), john_roney(), contributor("Yoko Ono"), contributor("John Lennon")],
        publishers=[effendi_records(), contributor("Effendi Records")])

    chain_of_title.update(lyricists=["Joel Miller"], composers=["John Lennon"], publishers=["Effendi Records"])

    assert_that(chain_of_title, not_(any_of(has_key("John Roney"), has_key("Yoko Ono"), has_key("Universals"))),
                "The chain of title")
Exemplo n.º 11
0
def test_removes_deprecated_frames_on_save(mp3):
    filename = mp3(TXXX_Tagger="TGiT v1.1",
                   TXXX_TAGGING_TIME="2014-03-26 14:18:55 EDT-0400",
                   TXXX_UPC="987654321111")
    container.save(filename, Metadata())

    tags = MP3(filename)
    assert_that(tags, all_of(not_(has_key("TXXX:Tagger")),
                             not_(has_key("TXXX:TAGGING_TIME")),
                             not_(has_key("TXXX:UPC"))), "tags in file")
Exemplo n.º 12
0
def task_information_is_retrieved(context):
    """TASK status data is retrieved"""

    assert_that(str(context.response.status_code), is_(equal_to("200")),
                "HTTP Status code is for TASK INFORMATION request not the expected one.")

    assert_that(context.body, has_key('taskId'),
                "The response of TASK INFORMATION request does not contain the expected attribute.")

    assert_that(context.body, has_key('status'),
                "The response of TASK INFORMATION request does not contain the expected attribute.")
Exemplo n.º 13
0
    def test_to_user_data(self):
        line_sip = LineSIP()
        line_sip.private_value = 'private_value'
        provisioning_extension = line_sip.provisioning_extension = '192837'
        username = line_sip.username = '******'

        line_sip_dict = line_sip.to_user_data()

        assert_that(line_sip_dict, has_entries({
            'provisioning_extension': provisioning_extension,
            'username': username,
        }))
        assert_that(line_sip_dict, all_of(is_not(has_key('private_value')),  # not mapped
                                          is_not(has_key('secret'))))  # not set
Exemplo n.º 14
0
    def test_swagger(self):
        response = self.client.get("/api/swagger")
        assert_that(response.status_code, is_(equal_to(200)))
        data = loads(response.data)

        upload = data["paths"]["/file"]["post"]
        upload_for = data["paths"]["/person/{person_id}/file"]["post"]

        # both endpoints return form data
        assert_that(
            upload["consumes"],
            contains("multipart/form-data"),
        )
        assert_that(
            upload_for["consumes"],
            contains("multipart/form-data"),
        )

        # one endpoint gets an extra query string parameter (and the other doesn't)
        assert_that(
            upload["parameters"],
            has_item(
                has_entries(name="extra"),
            ),
        )
        assert_that(
            upload_for["parameters"],
            has_item(
                is_not(has_entries(name="extra")),
            ),
        )

        # one endpoint gets a custom response type (and the other doesn't)
        assert_that(
            upload["responses"],
            all_of(
                has_key("204"),
                is_not(has_key("200")),
                has_entry("204", is_not(has_key("schema"))),
            ),
        )
        assert_that(
            upload_for["responses"],
            all_of(
                has_key("200"),
                is_not(has_key("204")),
                has_entry("200", has_entry("schema", has_entry("$ref", "#/definitions/FileResponse"))),
            ),
        )
Exemplo n.º 15
0
    def test_create_data_set(self):
        self.engine.create_data_set('should_have_index', 0)

        coll = self.engine._collection('should_have_index')
        indicies = coll.index_information()

        assert_that(indicies, has_key('_timestamp_-1'))
Exemplo n.º 16
0
    def test_volume_type_with_authentication(self):
        self.having_config('api_auth_token', 'some token value')
        self.controller.should_receive('get_volume_type') \
            .with_args('A_VOLUME_TYPE_ID') \
            .and_return([a(volume_type().with_volume_type_id('A_VOLUME_TYPE_ID')
                           .with_volume_type_name('some_volume_type_name'))]) \
            .once()

        code, result = self.api_get('/volume_type/A_VOLUME_TYPE_ID', headers={'X-Auth-Token': 'some token value'})

        assert_that(code, equal_to(200))
        assert_that(result, has_length(1))
        assert_that(result[0], has_key('volume_type_id'))
        assert_that(result[0]['volume_type_id'], equal_to('A_VOLUME_TYPE_ID'))
        assert_that(result[0], has_key('volume_type_name'))
        assert_that(result[0]['volume_type_name'], equal_to('some_volume_type_name'))
 def test_bulk_with_report(self):
     results = self.store.bulk(
         actions=[
             ("index", self.kevin),
             ("delete", self.steph),
         ],
         batch_size=2,
     )
     assert_that(
         self.store.retrieve(self.kevin.id),
         all_of(
             has_property("id", self.kevin.id),
             has_property("first", "Kevin"),
             has_property("middle", none()),
             has_property("last", "Durant"),
         ),
     )
     result = results[0]
     # Updated items
     assert_that(result[0], is_(equal_to(1)))
     # Report on failed to delete items
     assert_that(result[1], contains(
         has_key('delete'),
     ))
     assert_that(result[1][0]['delete'], has_entry('result', 'not_found'))
    def test_remove_module_from_existing_dashboard(
            self,
            mock_list_organisations,
            mock_list_data_sets,
            mock_list_module_types,
            client):
        data = {
            'slug': 'my-valid-slug',
            'title': 'My valid title',
            'modules-0-slug': 'carers-realtime',
            'modules-0-data_group': 'carers-allowance',
            'modules-0-data_type': 'realtime',
            'modules-0-options': '{}',
            'modules-0-query_parameters': '{}',
            'modules-0-id': 'module-uuid',
            'remove_module_0': 'remove',
        }

        client.post(
            '/admin/dashboards/uuid', data=data)

        with client.session_transaction() as session:
            assert_that(session['pending_dashboard'],
                        has_key('slug'))
            assert_that(len(session['pending_dashboard']['modules']),
                        equal_to(0))
Exemplo n.º 19
0
    def test_swagger(self):
        response = self.client.get("/api/swagger")
        assert_that(response.status_code, is_(equal_to(200)))
        data = loads(response.data)

        alias = data["paths"]["/person/{person_name}"]["get"]
        assert_that(
            alias["responses"],
            has_key("302"),
        )

        retrieve = data["paths"]["/person/{person_id}"]["get"]
        assert_that(
            retrieve["responses"],
            has_key("200"),
        )
Exemplo n.º 20
0
def EventNotification_FileReadyToParse_SyntaxKeywords_SeedWithCache_test(
    ycm, *args ):

  current_buffer = VimBuffer( name = 'current_buffer',
                              filetype = 'some_filetype' )

  with patch( 'ycm.client.event_notification.EventNotification.'
              'PostDataToHandlerAsync' ) as post_data_to_handler_async:
    with MockVimBuffers( [ current_buffer ], [ current_buffer ] ):
      ycm.OnFileReadyToParse()
      assert_that(
        # Positional arguments passed to PostDataToHandlerAsync.
        post_data_to_handler_async.call_args[ 0 ],
        contains(
          has_entry( 'syntax_keywords', has_items( 'foo', 'bar' ) ),
          'event_notification'
        )
      )

      # Do not send again syntax keywords in subsequent requests.
      ycm.OnFileReadyToParse()
      assert_that(
        # Positional arguments passed to PostDataToHandlerAsync.
        post_data_to_handler_async.call_args[ 0 ],
        contains(
          is_not( has_key( 'syntax_keywords' ) ),
          'event_notification'
        )
      )
Exemplo n.º 21
0
def task_finishes_with_status(context, status):
    """Wait for task finished: status != syncing"""

    i = 0
    task_status = None
    while i < MAX_WAIT_TASK_FINISHED:
        body, response = \
            context.glancesync_api_client.get_task_api_client(context.region_name).get_task_details(context.task_id)

        assert_that(str(response.status_code), is_(equal_to("200")),
                    "HTTP Status code is for TASK request not the expected one.")

        assert_that(body, has_key('status'),
                    "The response of TASK request does not contain the expected attribute.")

        task_status = body['status']
        if task_status != "syncing":
            break

        __logger__.info("#%s Waiting for TASK final status. Status: %s", i, status)
        time.sleep(WAIT_SECONDS)
        i += 1

    assert_that(task_status, is_(equal_to(status)),
                "The task has not been successfully executed.")
Exemplo n.º 22
0
    def test_add_a_module_to_a_dashboard(self):
        existing_modules_count = len(Module.objects.all())
        resp = self.client.post(
            '/dashboard/{}/module'.format(self.dashboard.slug),
            data=json.dumps({
                'slug': 'a-module',
                'type_id': str(self.module_type.id),
                'title': 'Some module',
                'description': 'Some text about the module',
                'info': ['foo'],
                'options': {
                    'thing': 'a value',
                },
                'objects': "some object",
                'order': 1,
                'modules': [],
            }),
            HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
            content_type='application/json')

        assert_that(resp.status_code, is_(equal_to(200)))
        assert_that(
            len(Module.objects.all()),
            greater_than(existing_modules_count))

        resp_json = json.loads(resp.content)

        assert_that(resp_json, has_key('id'))
        assert_that(resp_json, has_entry('slug', 'a-module'))
        assert_that(resp_json, has_entry('options', {'thing': 'a value'}))

        stored_module = Module.objects.get(id=resp_json['id'])
        assert_that(stored_module, is_not(None))
 def test_parses_non_list_based_data_points(self):
     options = {
         'mappings': {
             'nb_visits_converted': 'converted',
             'nb_conversions': 'sessions'},
         'idMapping': [
             'dataType', '_timestamp', 'timeSpan']
     }
     parser = Parser(query(), options, 'journey-by-goal')
     data = get_piwik_data(
         filename='piwik_goal_completion', period='weekly')
     parsed_data = parser.parse(data)
     assert_that(parsed_data[0], has_key('converted'))
     assert_that(parsed_data[0], has_key('sessions'))
     assert_that(parsed_data[0]['converted'], equal_to(730))
     assert_that(parsed_data[0]['sessions'], equal_to(730))
Exemplo n.º 24
0
    def test_spotlightify_handles_other_and_transaction_links(self):
        self.dashboard.add_other_link('other', 'http://www.gov.uk')
        self.dashboard.add_other_link('other2', 'http://www.gov.uk')
        self.dashboard.update_transaction_link(
            'transaction',
            'http://www.gov.uk'
        )
        self.dashboard.validate_and_save()
        transaction_link = self.dashboard.get_transaction_link()
        assert_that(transaction_link, instance_of(Link))
        assert_that(
            transaction_link.link_type,
            equal_to('transaction')
        )
        assert_that(
            self.dashboard.get_other_links()[0].link_type,
            equal_to('other')
        )
        assert_that(
            self.dashboard.spotlightify(),
            has_entries({
                'title': 'title',
                'page-type': 'dashboard',
                'relatedPages': has_entries({
                    'improve-dashboard-message': True,
                    'transaction':
                    has_entries({
                        'url': 'http://www.gov.uk',
                        'title': 'transaction',
                    }),
                    'other':
                    has_items(
                        has_entries({
                            'url': 'http://www.gov.uk',
                            'title': 'other',
                        }),
                        has_entries({
                            'url': 'http://www.gov.uk',
                            'title': 'other2',
                        }),
                    )
                })
            })
        )

        assert_that(self.dashboard.spotlightify(), is_not(has_key('id')))
        assert_that(self.dashboard.spotlightify(), is_not(has_key('link')))
Exemplo n.º 25
0
def test_load_multiple_files():
    """
    Registry can load multiple files.
    """
    registry = Registry()

    schema_ids = registry.load(
        schema_for("data/address.json"),
        schema_for("data/name.json"),
    )
    assert_that(schema_ids, has_length(2))
    assert_that(schema_ids, has_item(ADDRESS_ID))
    assert_that(schema_ids, has_item(NAME_ID))

    assert_that(registry, has_length(2))
    assert_that(registry, has_key(ADDRESS_ID))
    assert_that(registry, has_key(NAME_ID))
def step_impl(context, number):
    try:
        context.json_object = json.loads(context.rv.body)
        assert_that(context.json_object, has_key("unseen"))
        assert_that(context.json_object["unseen"], equal_to(int(number)))

    except ValueError, e:
        return False
Exemplo n.º 27
0
def step_impl(context, boolean):
    if boolean == "True":
        boolean_value = True
    else:
        boolean_value = False

    context.json_object = json.loads(context.rv.body)
    assert_that(context.json_object, has_key("game"))
    assert_that(context.json_object["game"], equal_to(boolean_value))
Exemplo n.º 28
0
    def test_get(self):
        data_source = DataSourceFactory()
        response = self.client.get(
            '/data-source/{}'.format(data_source.name),
            HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
            content_type='application/json')

        assert_that(response.status_code, equal_to(200))

        resp_json = json.loads(response.content)

        assert_that(resp_json['id'], equal_to(str(data_source.id)))
        assert_that(resp_json['slug'], equal_to(data_source.slug))
        assert_that(resp_json['name'], equal_to(data_source.name))
        assert_that(
            resp_json['provider']['name'], equal_to(data_source.provider.name))
        assert_that(resp_json, not(has_key('credentials')))
        assert_that(resp_json, not(has_key('owners')))
Exemplo n.º 29
0
 def test_table_parameterized(self, query_result_example, query_results):
     if 'results' in query_result_example:
         assert_that(query_results.table,
                     has_length(len(
                         query_result_example['results']['bindings'])))
     else:
         assert_that(query_results.table[0],
                     has_key('boolean'))
         assert_that(query_results.table, has_length(1))
Exemplo n.º 30
0
    def test_when_deleting_func_key_then_removes_func_key_from_template(self):
        funckey = Mock(FuncKey)
        template = FuncKeyTemplate(keys={1: funckey})
        self.service.get.return_value = template

        self.manipulator.remove_funckey(sentinel.template_id, 1)

        assert_that(template.keys, is_not(has_key(1)))
        self.service.get.assert_called_once_with(sentinel.template_id)
        self.service.edit.assert_called_once_with(template)
 def test_default_pagination(self):
     """Results are paginated without specifying params."""
     view = View.as_view({"get": "list"})
     request = APIRequestFactory().get("/")
     response = view(request)
     # check the response is successful
     self.assertEqual(response.status_code, status.HTTP_200_OK)
     resp_json = get_json_from_response(response)
     # check the JSON:API pagination params are present
     # https://jsonapi.org/format/#fetching-pagination
     pagination_keys = ["first", "last", "prev", "next"]
     assert_that(
         resp_json,
         has_entry("links", all_of(*[has_key(key) for key in pagination_keys])),
     )
Exemplo n.º 32
0
    def test_override_inheritance(self):
        """
        Registering an associated schema with an already-used suffix should raise

        """
        class ParentSchema(Schema):
            someField = fields.String(attribute="some_field")

        add_associated_schema("Bar", [], (ParentSchema, ))(PersonSchema)
        associated_schema = get_associated_schema(PersonSchema, "Bar")

        assert_that(
            associated_schema._declared_fields,
            has_key("someField"),
        )
 def test_that_config_includes_a_backends_list_if_config_contains_backends_definition(self):
     root = ET.Element('config')
     backends = ET.SubElement(root, 'backends')
     name = 'db'
     plugin = 'mysql'
     ET.SubElement(backends, 'backend', {'name':name, 'plugin':plugin})
     op = BackendParser()
     _dump_xml_as_file(root, 'backend.xml')
     op.parse(root)
     result = op.backends
     
     assert_that(result, is_not(None))
     assert_that(len(result), is_not(0))
     assert_that(result, has_key(name))
     assert_that(result[name].plugin, is_(plugin))
Exemplo n.º 34
0
 def bus_received_msg():
     assert_that(
         msg_accumulator.accumulate(with_headers=True),
         contains_exactly(
             has_entries(
                 message=has_entries(
                     data={
                         'user_uuid': user['uuid'],
                         'external_auth_name': 'foo',
                     }
                 ),
                 headers=has_key('tenant_uuid'),
             )
         ),
     )
Exemplo n.º 35
0
    def test_validate_total_length(self):
        body = dict(
            transport='tcp',
            sip_username='******',
            auth_password='******',
            auth_username='******',
            remote_host='remote_host_really_really_really_really_really_really_really_long_string',
            remote_port=6666,
            callback_extension='callback_extension_really_long_string',
        )

        assert_that(
            calling(self.schema.load).with_args(body),
            raises(ValidationError, has_property('messages', has_key('_schema'))),
        )
Exemplo n.º 36
0
 def compare_nodes(self, actual_node, node):
     assert_that(unqualify(node.tag), equal_to(unqualify(actual_node.tag)))
     assert_that(node, has_length(len(actual_node)))
     if node.text is not None:
         if node.text.strip() == "":
             assert_that(actual_node.text is None
                         or actual_node.text.strip() == "")
         else:
             assert_that(node.text.strip(),
                         equal_to(actual_node.text.strip()))
     for name, value in node.attrib.items():
         assert_that(actual_node.attrib, has_key(name))
         assert_that(actual_node.attrib[name], equal_to(value))
     assert_that(actual_node.nsmap, equal_to(node.nsmap))
     self.compare_children(node, actual_node)
Exemplo n.º 37
0
    def test_event_marshaller(self):
        event = MockEvent('marshaller', id=1234, value='something')

        with self.remote_event(event.name):
            self.local_bus.publish(event)

            assert_that(
                self.remote_messages(event.name, 1),
                has_items(
                    has_entry('data', has_entries(id=1234, value='something')),
                    has_entry('name', 'marshaller'),
                    has_entry('origin_uuid', self.local_bus.service_uuid),
                    has_key('timestamp'),
                ),
            )
Exemplo n.º 38
0
    def test_address_field(self):
        params = {'emails': [ONE, SIX]}
        body, error = self.user_schema.load(params)
        field = list(error['emails'][1].keys())[0]
        assert_that(field, equal_to('address'))

        params = {'emails': [ONE, TWO, TWO]}
        body, error = self.user_schema.load(params)
        assert_that(
            error,
            has_entries(
                _schema=contains('The same address can only be used once')))

        params = {}
        body, error = self.user_schema.load(params)
        assert_that(error, has_key('emails'))
Exemplo n.º 39
0
def test_signals_main_artist_only_when_album_is_compilation(driver):
    track = make_track()
    album = make_album(compilation=False, tracks=[track])

    metadata_changed_signal = KeywordsValueMatcherProbe("metadata changed")
    _ = show_page(album,
                  track,
                  on_track_changed=metadata_changed_signal.received)

    metadata_changed_signal.expect(is_not(has_key("lead_performer")))
    driver.change_track_title("Title")
    driver.check(metadata_changed_signal)

    metadata_changed_signal.expect(has_entries(recording_time="2008-09-15"))
    driver.change_recording_time(2008, 9, 15)
    driver.check(metadata_changed_signal)
Exemplo n.º 40
0
    def test_post(self):
        provider = {"name": "some-provider", "slug": "some-provider"}

        resp = self.client.post(
            '/provider',
            data=json.dumps(provider),
            HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
            content_type='application/json')

        assert_that(resp.status_code, equal_to(200))

        resp_json = json.loads(resp.content)

        assert_that(resp_json, has_key('id'))
        assert_that(resp_json['name'], equal_to('some-provider'))
        assert_that(resp_json['slug'], equal_to('some-provider'))
Exemplo n.º 41
0
def test_removes_linked_publisher_from_a_contributor_when_removing_a_publisher(
):
    chain_of_title = make_chain_of_title(
        authors_composers=[joel_miller(), john_roney()],
        publishers=[effendi_records()])

    chain_of_title.update(lyricists=["Joel Miller"],
                          composers=["John Roney"],
                          publishers=[])

    assert_that(
        chain_of_title.contributors,
        all_of(has_author_composer("John Roney", has_entry("publisher", "")),
               has_author_composer("Joel Miller", has_entry("publisher", "")),
               has_entry("publishers", not_(has_key("Effendi Records")))),
        "The chain of title")
Exemplo n.º 42
0
    def test_create(self, group_uuid, tenant_uuid):
        name = 'foobar'

        assert_that(group_uuid, equal_to(ANY_UUID))
        filter_ = models.Group.uuid == group_uuid
        group = self.session.query(models.Group).filter(filter_).first()
        assert_that(group, has_properties(name=name, tenant_uuid=tenant_uuid))

        assert_that(
            calling(self._group_dao.create).with_args(name, tenant_uuid),
            raises(exceptions.ConflictException).matching(
                has_properties(
                    'status_code', 409, 'resource', 'groups', 'details', has_key('name')
                )
            ),
        )
Exemplo n.º 43
0
    def test_inherits_external_can_create(self):
        class IExt(interface.Interface):
            interface.taggedValue('__external_class_name__', 'Ext')

        class Base(object):
            __external_can_create__ = False

        @interface.implementer(IExt)
        class E(Base):
            pass

        AutoPackage._ap_handle_one_potential_factory_class(E, 'nti.package', E)

        assert_that(E, has_property('__external_can_create__', False))

        assert_that(E.__dict__, does_not(has_key('__external_can_create__')))
Exemplo n.º 44
0
 def test_import_c_accel(self):
     import sys
     old_pp = FUT.PURE_PYTHON
     assert not hasattr(sys, 'import_c_accel')
     sys.import_c_accel = self
     try:
         FUT.PURE_PYTHON = False
         d = {'__name__': 'foo', 'import_c_accel': self}
         FUT.import_c_accel(d, 'sys')
         assert_that(d, has_key('modules'))
         assert_that(d, has_entry('__name__', 'sys'))
         self.assertNotIn('import_c_accel', d)
         FUT.import_c_accel(d, 'sys')
     finally:
         FUT.PURE_PYTHON = old_pp
         del sys.import_c_accel
Exemplo n.º 45
0
def validate_response_setting(context):
    response = context.response_setting
    assert_that(response.status_code, equal_to(HTTPStatus.OK))
    setting = json.loads(response.data)
    assert_that(response.status_code, equal_to(HTTPStatus.OK))
    assert_that(setting, has_key('uuid'))
    assert_that(setting, has_key('systemUnit'))
    assert_that(setting['systemUnit'], equal_to('imperial'))
    assert_that(setting, has_key('timeFormat'))
    assert_that(setting, has_key('dateFormat'))
    assert_that(setting, has_key('optIn'))
    assert_that(setting['optIn'], equal_to(True))
    assert_that(setting, has_key('ttsSettings'))
    tts = setting['ttsSettings']
    assert_that(tts, has_key('module'))
Exemplo n.º 46
0
def the_api_information_has_these_attributes(context):
    """Check that the response of the request has the given values"""

    for element in context.table.rows:
        attribute_key = element['attribute_name']
        assert_that(context.body, has_key(attribute_key),
                    "Missing attribute in the response")

        if element['value'] == FEATURES_NOT_EMPTY_VALUE:
            assert_that(context.body[attribute_key],
                        has_length(greater_than(0)), "Empty attribute value")
        else:
            attribute_value = element['value']
            assert_that(
                context.body[attribute_key], is_(equal_to(attribute_value)),
                "Attribute '{}' does not have the expected value".format(
                    attribute_key))
Exemplo n.º 47
0
def test_reset_to_autoprov_device_associated_to_line(provd, device, line):
    with a.line_device(line, device, check=False):
        response = confd.devices(device['id']).autoprov.get()
        response.assert_ok()

        response = confd.lines(line['id']).get()
        assert_that(response.item, has_entry('device_id', none()))

        device_cfg = provd.devices.get(device['id'])
        assert_that(device_cfg, has_entries(config=starts_with('autoprov')))
        assert_that(device_cfg, is_not(has_key('options')))

        config_cfg = provd.configs.get(device_cfg['config'])
        assert_that(config_cfg, not_none())

        response = confd.lines(line['id']).get()
        assert_that(response.item, has_entries(device_id=none()))
Exemplo n.º 48
0
def test_given_resources_already_exist_when_importing_then_resources_associated(
    sip, extension, extension_incall, voicemail, call_permission
):
    csv = [
        {
            "firstname": "importassociate",
            "exten": extension['exten'],
            "context": extension['context'],
            "line_protocol": "sip",
            "sip_username": sip['username'],
            "incall_exten": extension_incall['exten'],
            "incall_context": extension_incall['context'],
            "voicemail_number": voicemail['number'],
            "voicemail_context": voicemail['context'],
            "call_permissions": call_permission['name'],
        }
    ]

    response = client.post("/users/import", csv)

    user_id = get_import_field(response, 'user_id')
    line_id = get_import_field(response, 'line_id')
    extension_incall_id = get_import_field(response, 'incall_extension_id')

    response = confd.users(user_id).lines.get()
    assert_that(response.items, contains(has_entries(line_id=line_id)))

    response = confd.lines(line_id).extensions.get()
    assert_that(response.items, has_items(has_entries(extension_id=extension['id'])))

    response = confd.extensions(extension_incall_id).get()
    assert_that(response.item['incall'], has_key('id'))

    response = confd.users(user_id).voicemail.get()
    assert_that(response.item, has_entries(voicemail_id=voicemail['id']))

    response = confd.lines(line_id).endpoints.sip.get()
    assert_that(response.item, has_entries(endpoint='sip', endpoint_id=sip['id']))

    response = confd.users(user_id).callpermissions.get()
    assert_that(
        response.items,
        contains(
            has_entries(call_permission_id=call_permission['id'], user_id=user_id)
        ),
    )
Exemplo n.º 49
0
    def test_when_user_list_cdr_with_arg_user_uuid_then_user_uuid_is_ignored(
            self):
        SOME_TOKEN = 'my-token'
        self.auth.set_token(MockUserToken(SOME_TOKEN, user_uuid=USER_1_UUID))

        self.call_logd.set_token(SOME_TOKEN)
        result = self.call_logd.cdr.list_from_user(user_uuid=USER_2_UUID)
        self.call_logd.set_token(VALID_TOKEN)

        assert_that(
            result,
            has_entries(filtered=1,
                        total=1,
                        items=contains(
                            has_entries(start='2017-04-11T00:00:00+00:00'), )))
        assert_that(result,
                    has_entries(items=only_contains(not_(has_key('tags')))))
Exemplo n.º 50
0
    def test_spotlightify_with_no_data_set(self):
        module = ModuleFactory(slug='a-module',
                               type=self.module_type,
                               dashboard=self.dashboard_a,
                               order=1,
                               options={
                                   'foo': 'bar',
                               },
                               query_parameters={'sort_by': 'foo'})

        spotlight_module = module.spotlightify()

        assert_that(spotlight_module['slug'], equal_to('a-module'))
        assert_that(spotlight_module['foo'], equal_to('bar'))
        assert_that(spotlight_module['module-type'],
                    equal_to(self.module_type.name))
        assert_that(spotlight_module, is_not(has_key('data-source')))
Exemplo n.º 51
0
    def test_post(self):
        transform_type = TransformTypeFactory()
        input_data_type = DataTypeFactory()
        input_data_group = DataGroupFactory()
        output_data_type = DataTypeFactory()
        output_data_group = DataGroupFactory()

        payload = {
            "type_id": str(transform_type.id),
            "input": {
                "data-type": input_data_type.name,
                "data-group": input_data_group.name,
            },
            "query-parameters": {},
            "options": {},
            "output": {
                "data-type": output_data_type.name,
                "data-group": output_data_group.name,
            },
        }

        resp = self.client.post(
            '/transform',
            data=json.dumps(payload),
            HTTP_AUTHORIZATION='Bearer development-oauth-access-token',
            content_type='application/json')

        assert_that(resp.status_code, equal_to(200))

        resp_json = json.loads(resp.content)

        assert_that(resp_json, has_key('id'))
        assert_that(resp_json['type']['id'], equal_to(str(transform_type.id)))
        assert_that(resp_json['input']['data-type'],
                    equal_to(input_data_type.name))
        assert_that(resp_json['input']['data-group'],
                    equal_to(input_data_group.name))
        assert_that(resp_json['output']['data-type'],
                    equal_to(output_data_type.name))
        assert_that(resp_json['output']['data-group'],
                    equal_to(output_data_group.name))

        assert_that(
            Transform.objects.get(id=resp_json['id']).owners.first().email,
            equal_to('*****@*****.**'))
    def test_shouldInvokeCallbackThatIsRegisteredWithInstanceWhenFlowIsComplete(
            self):
        authorized_permission = PermissionObjectFactory()
        authorized_user = UserObjectFactory(
            user_permissions=[authorized_permission])
        content_type = ContentType.objects.get_for_model(BasicTestModel)

        state1 = RawState("state1")
        state2 = RawState("state2")
        state3 = RawState("state3")

        authorization_policies = [
            AuthorizationPolicyBuilder().with_permission(
                authorized_permission).build(),
        ]
        flow = FlowBuilder("my_field", content_type) \
            .with_transition(state1, state2, authorization_policies) \
            .with_transition(state2, state3, authorization_policies) \
            .build()

        workflow_object = flow.objects[0]

        self.hook_post_complete(flow.workflow, workflow_object=workflow_object)
        assert_that(self.get_output(), none())

        assert_that(workflow_object.my_field, equal_to(flow.get_state(state1)))
        workflow_object.river.my_field.approve(as_user=authorized_user)
        assert_that(workflow_object.my_field, equal_to(flow.get_state(state2)))

        assert_that(self.get_output(), none())

        workflow_object.river.my_field.approve(as_user=authorized_user)
        assert_that(workflow_object.my_field, equal_to(flow.get_state(state3)))

        output = self.get_output()
        assert_that(output, has_length(1))
        assert_that(output[0], has_key("hook"))
        assert_that(output[0]["hook"], has_entry("type", "on-complete"))
        assert_that(output[0]["hook"], has_entry("when", AFTER))
        assert_that(
            output[0]["hook"],
            has_entry(
                "payload",
                has_entry(equal_to("workflow_object"),
                          equal_to(workflow_object))))
Exemplo n.º 53
0
    def test_when_create_http_subscription_then_subscription_no_error(self):
        webhookd = self.make_webhookd(MASTER_TOKEN)

        response = webhookd.subscriptions.create(TEST_SUBSCRIPTION)
        subscription_uuid = response['uuid']

        assert_that(response, has_entries(owner_tenant_uuid=MASTER_TENANT))

        assert_that(response, has_key('uuid'))

        response = webhookd.subscriptions.list()
        assert_that(
            response, has_entry('items', has_item(has_entry('uuid', subscription_uuid)))
        )
        assert_that(
            response,
            has_entry('items', has_item(has_entry('owner_tenant_uuid', MASTER_TENANT))),
        )
Exemplo n.º 54
0
 def test_for_author(self):
     with self.app.test_request_context():
         g.user = self.author
         result = self.call_serialize()
     assert_that(
         result,
         has_entries({
             'status': None,
             'contest_id': self.run.contest_id,
             'prob_id': 1,
             'run_id': self.run.run_id,
             'create_time': 'None',
             'lang_id': None,
             'score': None,
             'size': None,
         }))
     assert_that(result, has_entries(self.pynformatics_run_serialized))
     assert_that(result, is_not(has_key('user')))
Exemplo n.º 55
0
def check_bus_event(routing_key, url, body=None):
    bus_events = BusClient.accumulator(routing_key)
    url(body) if body else url()

    assertions = all_of(
        has_length(1),
        contains(
            has_entry(
                'headers',
                has_key('tenant_uuid'),
            )
        ),
    )

    def assert_function():
        assert_that(bus_events.accumulate(with_headers=True), assertions)

    until.assert_(assert_function, tries=5)
Exemplo n.º 56
0
def test_updates_cert_arn_for_supplied_distribution_id():
    # Given
    cf_wrapper = CloudfrontWrapper()

    the_existing_distribution_id = "some-distribution-id"
    initial_distribution_config_etag = "GetRequestEtag"

    cf_wrapper.get_distribution_config = Mock(
        return_value=a_boto3_cloudfront_get_distribution_response(
            with_acm_certificate_arn="old:certificate:arn",
            with_etag=initial_distribution_config_etag),
        side_effect=error_if_distribution_id_not(the_existing_distribution_id),
    )
    cf_wrapper.update_distribution_config = MagicMock()

    # When
    new_cert_arn = "new:certificate:arn"
    CertRotator(cf_wrapper).rotate_cert(the_existing_distribution_id,
                                        new_cert_arn)

    # Then

    # Updates distribution
    cf_wrapper.update_distribution_config.assert_called_once
    update_call_args = cf_wrapper.update_distribution_config.call_args_list[0][
        1]

    # updates correct distribution id
    assert_that(update_call_args["distribution_id"],
                is_(the_existing_distribution_id))

    # includes the etag from the latest fetched config
    assert_that(update_call_args["if_etag_matches"],
                is_(initial_distribution_config_etag))

    # distribution config supplied includes viewer certificate info
    distribution_config = update_call_args["distribution_configuration"]
    viewer_certificate = distribution_config["ViewerCertificate"]

    # ... with new cert
    assert_that(viewer_certificate["ACMCertificateArn"], is_(new_cert_arn))

    # ... but without deprecated 'Certificate' field which is present in the get distribution config response
    assert_that(viewer_certificate, not_(has_key("Certificate")))
Exemplo n.º 57
0
def check_json(json_expected, json_response):
    if type(json_expected) is list:
        for i in range(0, len(json_expected)):
            check_json(json_expected[i], json_response[i])
            check_json(json_response[i], json_expected[i])
    elif type(json_expected) is dict:
        for key, value in json_expected.items():
            if type(value) is dict:
                assert_that(json_response, has_key(key))
                check_json(value, json_response[key])
                check_json(json_response[key], value)
            elif type(value) is list:
                for i in range(0, len(value)):
                    check_json(json_expected[key][i], json_response[key][i])
                    check_json(json_response[key][i], json_expected[key][i])
            else:
                assert_that(json_response, has_entry(key, value))
    else:
        assert_that(json_response, equal_to(json_expected))
Exemplo n.º 58
0
    def test_expected_exceptions_still_have_cors(self):

        def raises_app(environ, start_response):
            raise IOError('bad')

        catching_app = ErrorMiddleware(raises_app)
        app = cors_filter_factory(catching_app)

        testapp = TestApp(app)
        res = testapp.get('/the_path_doesnt_matter', status=500)

        assert_that(res.normal_body, is_(b'Failed to handle request bad'))

        # Errors set the right response headers
        res = testapp.get('/',
                          extra_environ={
                              'HTTP_ORIGIN': 'http://example.org'},
                          status=500)
        assert_that(res.headers, has_key('Access-Control-Allow-Origin'))
Exemplo n.º 59
0
    def test_validate_total_length(self):
        body = {
            'auth_username':
            '******',
            'auth_password':
            '******',
            'remote_host':
            'remote_host_really_really_really_really_really_really_really_long_string',
            'remote_port':
            6666,
            'callback_extension':
            'callback_extension_really_really_really_really_really_long_string',
        }

        assert_that(
            calling(self.schema.load).with_args(body),
            raises(ValidationError, has_property('messages',
                                                 has_key('_schema'))),
        )
Exemplo n.º 60
0
def LanguageServerCompleter_GetCompletions_UnsupportedKinds_test():
  completer = MockCompleter()
  request_data = RequestWrap( BuildRequest() )

  completion_response = { 'result': [ { 'label': 'test',
                                        'kind': len( lsp.ITEM_KIND ) + 1 } ] }

  resolve_responses = [
    { 'result': { 'label': 'test' } },
  ]

  with patch.object( completer, 'ServerIsReady', return_value = True ):
    with patch.object( completer.GetConnection(),
                       'GetResponse',
                       side_effect = [ completion_response ] +
                                     resolve_responses ):
      assert_that( completer.ComputeCandidatesInner( request_data ),
                   has_items( all_of( has_entry( 'insertion_text', 'test' ),
                                      is_not( has_key( 'kind' ) ) ) ) )