Example #1
0
    def test_active_subjects(self):
        '''GET /tasr/collection/subjects/active - gets _active_ subjects (that
        is, ones with at least one schema), as expected'''
        # reg two vers for target subject and one for an alt subject
        self.register_subject(self.event_type)
        alt_subject_name = 'bob'
        self.register_subject(alt_subject_name)
        # now get all and check the headers
        all_url = "%s/collection/subjects/all" % self.url_prefix
        resp = self.tasr_app.request(all_url, method='GET')
        self.abort_diff_status(resp, 200)
        meta_dict = SubjectHeaderBot.extract_metadata(resp)
        # we should have a GroupMetadata object for each group in the headers
        for sub_name in [self.event_type, alt_subject_name]:
            self.assertIn(sub_name, meta_dict.keys(), 'missing subject')
            subj = meta_dict[sub_name]
            self.assertEqual(sub_name, subj.name, 'bad subject name')

        # now get the ACTIVE subjects, which should be empty so far
        active_url = "%s/collection/subjects/active" % self.url_prefix
        resp = self.tasr_app.request(active_url, method='GET')
        self.abort_diff_status(resp, 200)
        meta_dict = SubjectHeaderBot.extract_metadata(resp)
        # we should have no GroupMetadata objects
        for sub_name in [self.event_type, alt_subject_name]:
            self.assertNotIn(sub_name, meta_dict.keys(), 'unexpected subject')

        # now register a schema for the base subject and recheck
        resp = self.register_schema(self.event_type, self.schema_str)
        self.abort_diff_status(resp, 201)

        # the get_all should be unchanged, the get_active should have one
        resp = self.tasr_app.request(all_url, method='GET')
        self.abort_diff_status(resp, 200)
        meta_dict = SubjectHeaderBot.extract_metadata(resp)
        # we should have a GroupMetadata object for each group in the headers
        for sub_name in [self.event_type, alt_subject_name]:
            self.assertIn(sub_name, meta_dict.keys(), 'missing subject')
            subj = meta_dict[sub_name]
            self.assertEqual(sub_name, subj.name, 'bad subject name')

        # now get the ACTIVE subjects, which should be empty so far
        resp = self.tasr_app.request(active_url, method='GET')
        self.abort_diff_status(resp, 200)
        meta_dict = SubjectHeaderBot.extract_metadata(resp)
        # we should have a GroupMetadata object for one group in the headers
        self.assertNotIn(alt_subject_name, meta_dict.keys(), 'unexpected obj')
        # the event_type should be there
        self.assertIn(self.event_type, meta_dict.keys(), 'missing subject')
        subj = meta_dict[self.event_type]
        self.assertEqual(self.event_type, subj.name, 'bad subject name')

        # lastly check the body
        buff = StringIO.StringIO(resp.body)
        group_names = []
        for topic_line in buff:
            group_names.append(topic_line.strip())
        buff.close()
        self.assertListEqual(sorted(group_names), sorted(meta_dict.keys()),
                             'Expected group_names in body to match headers.')
Example #2
0
 def test_get_all_topics(self):
     '''GET /tasr/topic - as expected'''
     # reg two vers for target topic and one for an alt topic
     self.register_schema(self.schema_str)
     schema_str_2 = self.schema_str.replace('tagged.events',
                                            'tagged.events.alt', 1)
     self.register_schema(schema_str_2)
     alt_topic = 'bob'
     alt_url = '%s/topic/%s' % (self.url_prefix, alt_topic)
     self.tasr_app.request(alt_url, method='PUT',
                           content_type=self.content_type,
                           body=self.schema_str)
     # now get all with versions and check the headers
     url = "%s/topic" % (self.url_prefix)
     resp = self.tasr_app.request(url, method='GET')
     self.abort_diff_status(resp, 200)
     # we expect a list of SubjectMetadata objects here
     meta_dict = SubjectHeaderBot.extract_metadata(resp)
     self.assertEqual(2, meta_dict[self.event_type].current_version,
                      'bad ver')
     self.assertEqual(1, meta_dict[alt_topic].current_version, 'bad ver')
     # lastly check the body
     buff = StringIO.StringIO(resp.body)
     group_names = []
     for topic_line in buff:
         group_names.append(topic_line.strip())
     buff.close()
     self.assertListEqual(sorted(group_names), sorted(meta_dict.keys()),
                          'Expected group_names in body to match headers.')
Example #3
0
File: client.py Project: ifwe/tasr
def get_all_subject_schema_ids(subject_name, host=TASR_HOST,
                               port=TASR_PORT, timeout=TIMEOUT):
    ''' GET /tasr/subject/<subject name>/all_ids
    Retrieves a list of the SHA256 multi-type IDs for all the schema versions
    registered for a subject, in version order.
    '''
    url = 'http://%s:%s/tasr/subject/%s/all_ids' % (host, port, subject_name)
    resp = requests.get(url, timeout=timeout)
    if resp == None:
        raise TASRError('Timeout for get all subject IDs request.')
    if resp.status_code != 200:
        raise TASRError('Failed to get all subject IDs (status code: %s)' %
                        resp.status_code)
    meta = SubjectHeaderBot.extract_metadata(resp)[subject_name]
    # check that the sha256_list matches the body list
    buff = StringIO.StringIO(resp.content)
    sha256_ids = []
    for line in buff:
        sha256_ids.append(line.strip())
    buff.close()
    if len(meta.sha256_id_list) != len(sha256_ids):
        raise TASRError('Header-body mismatch for sha256_id lists.')
    if meta.sha256_id_list != sha256_ids:
        raise TASRError('Header-body mismatch for sha256_id lists.')
    return meta.sha256_id_list
Example #4
0
    def test_all_subject_names(self):
        '''GET /tasr/collection/subjects/all - get _all_ registered subjects'''
        # reg two vers for target subject and one for an alt subject
        self.register_subject(self.event_type)
        alt_subject_name = 'bob'
        self.register_subject(alt_subject_name)
        # now get all and check the headers
        get_url = '%s/collection/subjects/all' % self.url_prefix
        resp = self.tasr_app.request(get_url, method='GET')
        self.abort_diff_status(resp, 200)
        meta_dict = SubjectHeaderBot.extract_metadata(resp)

        self.assertIn(self.event_type, meta_dict.keys(), 'missing subject')
        subj = meta_dict[self.event_type]
        self.assertEqual(self.event_type, subj.name, 'bad subject name')

        self.assertIn(alt_subject_name, meta_dict.keys(), 'missing subject')
        alt_subj = meta_dict[alt_subject_name]
        self.assertEqual(alt_subject_name, alt_subj.name, 'bad subject name')

        # lastly check the body
        buff = StringIO.StringIO(resp.body)
        group_names = []
        for topic_line in buff:
            group_names.append(topic_line.strip())
        buff.close()
        self.assertListEqual(sorted(group_names), sorted(meta_dict.keys()),
                             'Expected group_names in body to match headers.')
Example #5
0
File: client.py Project: ifwe/tasr
def get_all_subject_schemas(subject_name,
                            host=TASR_HOST, port=TASR_PORT, timeout=TIMEOUT):
    ''' GET /tasr/subject/<subject name>/all_schemas
    Retrieves all the (canonical) schema versions registered for a subject,
    in version order, one per line in the response body.  The multi-type IDs
    are included in the headers for confirmation.
    '''
    url = ('http://%s:%s/tasr/subject/%s/all_schemas' %
           (host, port, subject_name))
    resp = requests.get(url, timeout=timeout)
    if resp == None:
        raise TASRError('Timeout for get all subject schemas request.')
    if resp.status_code != 200:
        raise TASRError('Failed to get all subject schemas (status code: %s)' %
                        resp.status_code)
    meta = SubjectHeaderBot.extract_metadata(resp)[subject_name]
    buff = StringIO.StringIO(resp.content)
    schemas = []
    version = 1
    for schema_str in buff:
        ras = RegisteredAvroSchema()
        ras.schema_str = schema_str.strip()
        ras.gv_dict[subject_name] = version
        if ras.sha256_id != meta.sha256_id_list[version - 1]:
            raise TASRError('Generated SHA256 ID did not match passed ID.')
        schemas.append(ras)
        version += 1
    buff.close()
    return schemas
Example #6
0
File: client.py Project: ifwe/tasr
def get_all_subject_names(host=TASR_HOST, port=TASR_PORT, timeout=TIMEOUT):
    ''' GET /tasr/collection/subjects/all
    Retrieves all the registered subject names, both as X-TASR header fields
    and as plain text, one per line, in the response body.  This method returns
    a list of subject name strings.
    '''
    url = 'http://%s:%s/tasr/collection/subjects/all' % (host, port)
    resp = requests.get(url, timeout=timeout)
    if resp == None:
        raise TASRError('Timeout for get all subjects request.')
    if resp.status_code != 200:
        raise TASRError('Failed to get all subjects (status code: %s)' %
                        resp.status_code)
    subject_metas = SubjectHeaderBot.extract_metadata(resp)
    # check that subject_metas.keys() matches the body list
    buff = StringIO.StringIO(resp.content)
    name_list = []
    for line in buff:
        name_list.append(line.strip())
    buff.close()
    if len(subject_metas.keys()) != len(name_list):
        raise TASRError('Header-body mismatch for subject name lists.')
    if sorted(subject_metas.keys()) != sorted(name_list):
        raise TASRError('Header-body mismatch for subject name lists.')
    return subject_metas.keys()
Example #7
0
 def test_register_subject(self):
     '''PUT /tasr/subject - registers the subject (not the schema)'''
     resp = self.register_subject(self.event_type)
     self.abort_diff_status(resp, 201)
     metas = SubjectHeaderBot.extract_metadata(resp)
     self.assertEqual(self.event_type, metas[self.event_type].name,
                      'unexpected subject name')
Example #8
0
 def test_lookup_subject(self):
     '''GET /tasr/subject/<subject> - lookup the subject by name'''
     self.register_subject(self.event_type)
     resp = self.tasr_app.request(self.subject_url, method='GET')
     self.abort_diff_status(resp, 200)
     metas = SubjectHeaderBot.extract_metadata(resp)
     self.assertEqual(self.event_type, metas[self.event_type].name,
                      'unexpected subject name')
Example #9
0
 def test_reg_and_rereg_subject(self):
     '''PUT /tasr/subject - registers the subject (not the schema), then
     re-registers the same subject.  The second reg should return a 200.'''
     resp = self.register_subject(self.event_type)
     self.abort_diff_status(resp, 201)
     resp = self.register_subject(self.event_type)
     self.abort_diff_status(resp, 200)
     metas = SubjectHeaderBot.extract_metadata(resp)
     self.assertEqual(self.event_type, metas[self.event_type].name,
                      'unexpected subject name')
Example #10
0
    def test_active_subjects__accept_json(self):
        '''GET /tasr/collection/subjects/active - gets _active_ subjects (that
        is, ones with at least one schema), as expected'''
        # reg two vers for target subject and one for an alt subject
        self.register_subject(self.event_type)
        alt_subject_name = 'bob'
        self.register_subject(alt_subject_name)

        # now get the ACTIVE subjects, which should be empty so far
        active_url = "%s/collection/subjects/active" % self.url_prefix
        resp = self.tasr_app.request(active_url, method='GET',
                                     accept='text/json')
        self.abort_diff_status(resp, 200)
        meta_dict = SubjectHeaderBot.extract_metadata(resp)
        # we should have no GroupMetadata objects
        for sub_name in [self.event_type, alt_subject_name]:
            self.assertNotIn(sub_name, meta_dict.keys(), 'unexpected subject')
        # we should have received an empty dict as the content body
        active_dict = json.loads(resp.body)
        self.assertDictEqual({}, active_dict, 'expected empty dict')

        # now register a schema for the base subject and recheck
        resp = self.register_schema(self.event_type, self.schema_str)
        self.abort_diff_status(resp, 201)

        # now get the ACTIVE subjects, which should be empty so far
        resp = self.tasr_app.request(active_url, method='GET',
                                     accept='text/json')
        self.abort_diff_status(resp, 200)
        meta_dict = SubjectHeaderBot.extract_metadata(resp)
        # we should have a GroupMetadata object for one group in the headers
        self.assertNotIn(alt_subject_name, meta_dict.keys(), 'unexpected obj')
        # the event_type should be there
        self.assertIn(self.event_type, meta_dict.keys(), 'missing subject')
        subj = meta_dict[self.event_type]
        self.assertEqual(self.event_type, subj.name, 'bad subject name')

        # and check the expected content body JSON
        active_dict = json.loads(resp.body)
        self.assertListEqual(sorted(active_dict.keys()),
                             sorted(meta_dict.keys()),
                             'Expected group_names in body to match headers.')
Example #11
0
def get_all_topics(host=TASR_HOST, port=TASR_PORT, timeout=TIMEOUT):
    ''' GET /tasr/topic
    Retrieves available metadata for all the topics (i.e. -- groups) with
    registered schemas.  A dict of <topic name>:<topic metadata> is returned.
    '''
    url = 'http://%s:%s/tasr/topic' % (host, port)
    resp = requests.get(url, timeout=timeout)
    if resp == None:
        raise TASRError('Timeout for request to %s' % url)
    if not 200 == resp.status_code:
        raise TASRError('Failed request to %s (status code: %s)' %
                        (url, resp.status_code))
    topic_metas = SubjectHeaderBot.extract_metadata(resp)
    return topic_metas
Example #12
0
 def test_register_subject__accept_json(self):
     '''PUT /tasr/subject - registers the subject (not the schema)'''
     url = '%s/subject/%s' % (self.url_prefix, self.event_type)
     dummy_config = {'dummy_config_key': 'dummy_config_val'}
     resp = self.tasr_app.put(url, dummy_config, {'Accept': 'text/json'})
     self.abort_diff_status(resp, 201)
     metas = SubjectHeaderBot.extract_metadata(resp)
     self.assertEqual(self.event_type, metas[self.event_type].name,
                      'unexpected subject name')
     # check the returned JSON to ensure it worked
     json_sub = json.loads(resp.body)
     self.assertEqual(self.event_type, json_sub["subject_name"],
                      "bad subject name")
     self.assertEqual(dummy_config, json_sub["config"], "bad config")
Example #13
0
File: client.py Project: ifwe/tasr
def register_subject(subject_name, config_dict=None, host=TASR_HOST,
                     port=TASR_PORT, timeout=TIMEOUT):
    ''' PUT /tasr/subject/<subject name>
    Registers a _subject_ (not a schema), ensuring that the group can be
    established before associating schemas with it.  Note that if a form is
    sent as the PUT body, it should be used to set the subject config map.
    Returns a GroupMetadata object on success.
    '''
    url = 'http://%s:%s/tasr/subject/%s' % (host, port, subject_name)
    resp = requests.put(url, data=config_dict, timeout=timeout)
    if resp == None:
        raise TASRError('Timeout for register subject request.')
    if not resp.status_code in [200, 201]:
        raise TASRError('Failed to register subject. (status code: %s)' %
                        resp.status_code)
    subject_metas = SubjectHeaderBot.extract_metadata(resp)
    if subject_metas and len(subject_metas) > 0:
        return subject_metas[subject_name]
Example #14
0
    def test_all_subject_names__accept_json(self):
        '''GET /tasr/collection/subjects/all - get _all_ registered subjects'''
        # reg two vers for target subject and one for an alt subject
        self.register_subject(self.event_type)
        alt_subject_name = 'bob'
        self.register_subject(alt_subject_name)
        # now get all and check the headers
        get_url = '%s/collection/subjects/all' % self.url_prefix
        resp = self.tasr_app.request(get_url, method='GET', accept='text/json')
        self.abort_diff_status(resp, 200)
        meta_dict = SubjectHeaderBot.extract_metadata(resp)

        self.assertIn(self.event_type, meta_dict.keys(), 'missing subject')
        subj = meta_dict[self.event_type]
        self.assertEqual(self.event_type, subj.name, 'bad subject name')

        self.assertIn(alt_subject_name, meta_dict.keys(), 'missing subject')
        alt_subj = meta_dict[alt_subject_name]
        self.assertEqual(alt_subject_name, alt_subj.name, 'bad subject name')

        # the body should be a JSON dict of subject objects keyed by name
        sub_dict = json.loads(resp.body)
        self.assertListEqual(sorted(sub_dict.keys()), sorted(meta_dict.keys()),
                             'Expected group_names in body to match headers.')