Пример #1
0
    def test_20_bad_start(self):
        """(20) Test start session endpoint used by UI. Send an unknown field"""
        msgt(self.test_20_bad_start.__doc__)

        # url and info for call
        #
        url = reverse('StartSession')
        info = dict(user_agent='secret_agent_man',
                    unknown_field='what\'s this?')

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        # status code 'FAILED_PRECONDITION'
        #
        self.assertEqual(json_resp['responseInfo']['status']['code'],
                         STATUS_VAL_FAILED_PRECONDITION)

        # error message found
        #
        err_snippet = '"SessionRequest" has no field named "unknown_field"'
        idx = json_resp['responseInfo']['status']['details'].find(err_snippet)
        self.assertTrue(idx > -1)
Пример #2
0
    def test_10_good_start(self):
        """(10) Test start session endpoint used by UI"""
        msgt(self.test_10_good_start.__doc__)

        # url and info for call
        #
        url = reverse('StartSession')
        info = dict(user_agent='user_agent')

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        # status code 'OK'
        #
        self.assertEqual(json_resp['responseInfo']['status']['code'],
                         STATUS_VAL_OK)

        # sessionId returned
        #
        self.assertTrue('sessionId' in json_resp['context'])

        # session id length is reasonable
        #
        self.assertTrue(len(json_resp['context']['sessionId']) > 5)
Пример #3
0
    def test_30_bad_start(self):
        """(30) Test start session endpoint used by UI. Don't send a user agent"""
        msgt(self.test_30_bad_start.__doc__)

        # url and info for call
        #
        url = reverse('StartSession')
        info = dict()

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('response: ', json_resp)

        # status code 'FAILED_PRECONDITION'
        #
        self.assertEqual(json_resp['responseInfo']['status']['code'],
                         STATUS_VAL_FAILED_PRECONDITION)

        # error message found
        #
        idx = json_resp['responseInfo']['status']['details'].find(
            ERR_MSG_NO_USER_AGENT)
        self.assertTrue(idx > -1)
Пример #4
0
    def test_50_bad_end(self):
        """(50) Test the end session endpoint.  Error: Don't include a session_id"""
        msgt(self.test_50_bad_end.__doc__)

        # url and info for call
        #
        url = reverse('EndSession')
        info = dict(no_session_id='session_0')

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        # status code 'OK'
        #
        self.assertEqual(json_resp['status']['code'],
                         STATUS_VAL_FAILED_PRECONDITION)

        # error message found
        #
        idx = json_resp['status']['details'].find(ERR_NO_SESSION_ID)
        self.assertTrue(idx > -1)
Пример #5
0
    def test_20_send_badvar_name(self):
        """(20) Forget pipeline id and fail"""
        msgt(self.test_20_send_badvar_name.__doc__)


        # url and info for call
        #
        url = reverse('DescribeDataflow')
        info = dict(context=dict(xsessionId='session_01'))

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        #print('json_resp', json.dumps(json_resp, indent=4))

        # status code 'FAILED_PRECONDITION'
        #
        self.assertEqual(json_resp['responseInfo']['status']['code'],
                         STATUS_VAL_FAILED_PRECONDITION)

        # error message found
        #
        err_snippet = ("Message type \"SessionContext\""
                       " has no field named \"xsessionId\"")
        idx = json_resp['responseInfo']['status']['details'].find(err_snippet)
        self.assertTrue(idx > -1)
Пример #6
0
    def test_030_EndSearchSolutions(self):
        """(30) Test EndSearchSolutions"""
        msgt(self.test_030_EndSearchSolutions.__doc__)
        # url and info for call
        #
        url = reverse('EndSearchSolutions')

        info = dict(searchId='searchId')

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        self.assertTrue(json_resp['success'])
        self.assertTrue('data' in json_resp)

        print(ta2_static.END_SEARCH_SOLUTIONS)

        # Updated so that ending the search flushes the log to a file
        #  and deletes the entries...
        #
        cnt = BehavioralLogEntry.objects.all().count()
        self.assertEqual(cnt, 0)
Пример #7
0
    def test_20_list_workspaces_valid_user(self):
        """(20) List workspaces with a valid user"""
        msgt(self.test_20_list_workspaces_valid_user.__doc__)

        user = User.objects.get(username='******')

        #
        print('\n -- Retrieve the user workspaces.  Do NOT create a default one')
        #
        ws_info = ws_utils.get_user_workspaces(user, create_if_not_found=False)
        self.assertTrue(not ws_info.success)

        #
        print(('\n -- Retrieve the user workspaces.'
               ' Create if one not found. (This is the default behavior)'))
        #
        ws_info2 = ws_utils.get_user_workspaces(user)
        self.assertTrue(ws_info2.success)
        self.assertEqual(len(ws_info2.result_obj), 1)

        #
        print(('\n -- Retrieve the user workspaces as list of dicts.'))
        #
        ws_info3 = ws_utils.get_user_workspaces_as_dict(user)
        self.assertTrue(ws_info3.success)
        self.assertEqual(len(ws_info3.result_obj), 1)
Пример #8
0
    def test_30_workspace_by_view(self):
        """(30) Get workspace JSON via view"""
        msgt(self.test_30_workspace_by_view.__doc__)

        # Get a user
        user_obj = User.objects.get_or_create(username='******')[0]

        # Get workspace list for a legit id
        success, ws_list = WorkspaceRetriever.list_workspaces_by_user(user_obj)
        expected_workspace = ws_list[0]
        ws_id = expected_workspace.id

        # create a web client and login
        client = Client()
        client.force_login(user_obj)

        # retrieve the workspace
        url = reverse('view_workspace_by_id_json',
                      kwargs=dict(workspace_id=ws_id))

        response1 = client.get(url)

        # 200 status code
        #
        self.assertEqual(response1.status_code, 200)

        json_resp = response1.json()
        self.assertEqual(json_resp['app_domain'],
                         expected_workspace.app_domain)
        self.assertEqual(json_resp['user']['username'],
                         expected_workspace.user.username)
        self.assertEqual(json_resp['data_source_type']['name'],
                         expected_workspace.data_source_type.name)
Пример #9
0
    def test_10_good_request(self):
        """(10) Test endpoint used by UI, with successful result"""
        msgt(self.test_10_good_request.__doc__)

        # url and info for call
        #
        pipeline_id = 'pipeline_222'
        url = reverse('GetDataflowResults')
        info = dict(context=dict(sessionId='session_01'),
                    pipelineId=pipeline_id)

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        #print('json_resp', json_resp)

        #
        self.assertTrue(len(json_resp), 4)

        # 2nd result is status RUNNING
        #
        self.assertTrue(json_resp[1]['status'], 'RUNNING')

        # 3rd has two output entries
        #
        self.assertTrue(len(json_resp[2]['outputs']), 2)
Пример #10
0
    def test_10_list_workspaces_null_user(self):
        """(10) List workspaces by null user"""
        msgt(self.test_10_list_workspaces_null_user.__doc__)

        success, ws_list = WorkspaceRetriever.list_workspaces_by_user(None)
        self.assertEqual(success, False)
        self.assertEqual(ws_list, ERR_AUTH_USER_IS_NONE)
Пример #11
0
    def test_080_ProduceSolution(self):
        """(80) Test ProduceSolution"""
        msgt(self.test_080_ProduceSolution.__doc__)
        # url and info for call
        #
        url = reverse('ProduceSolution')

        req_str = render_to_string('test_requests/req_ProduceSolution.json',
                                   {})

        response = self.client.post(url,
                                    req_str,
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        self.assertTrue(json_resp['success'])
        self.assertTrue('data' in json_resp)
        self.assertTrue('requestId' in json_resp['data'])
Пример #12
0
    def test_050_DescribeSolution(self):
        """(50) Test DescribeSolution"""
        msgt(self.test_050_DescribeSolution.__doc__)
        # url and info for call
        #
        url = reverse('DescribeSolution')

        info = dict(solutionId='solutionId')

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        self.assertTrue(json_resp['success'])
        self.assertTrue('data' in json_resp)
        self.assertTrue('pipeline' in json_resp['data'])
        self.assertTrue('inputs' in json_resp['data']['pipeline'])
        self.assertTrue('outputs' in json_resp['data']['pipeline'])
        self.assertTrue('steps' in json_resp['data']['pipeline'])
        self.assertTrue('steps' in json_resp['data'])
Пример #13
0
    def test_10_redirect_to_login(self):
        """(10) Redirect to login when in D3M mode"""
        msgt(self.test_10_redirect_to_login.__doc__)

        # Attempt to go the main workspace
        #
        url = reverse('home')

        # --------------------------------
        # Look for 302 redirect
        # --------------------------------
        resp1 = self.client.get(url)

        # 302 response - redirect
        #
        self.assertEqual(resp1.status_code, 302)

        # --------------------------------
        # Follow redirect to login page
        # --------------------------------
        resp2 = self.client.get(url, follow=True)

        login_found = resp2.content.decode('utf-8').find(LOGIN_STR) > -1
        self.assertTrue(login_found)

        username_found = resp2.content.decode('utf-8').find(USERNAME_STR) > -1
        self.assertTrue(username_found)
Пример #14
0
    def test_040_StopSearchSolutions(self):
        """(40) Test StopSearchSolutions"""
        msgt(self.test_040_StopSearchSolutions.__doc__)
        # url and info for call
        #
        url = reverse('StopSearchSolutions')

        info = dict(searchId='searchId')

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        self.assertTrue(json_resp['success'])
        self.assertTrue('data' in json_resp)

        self.assertEqual(BehavioralLogEntry.objects.filter(\
                            feature_id=ta2_static.STOP_SEARCH_SOLUTIONS).count(), 1)
Пример #15
0
    def test_20_log_entry_valid(self):
        """(20) Send valid log entries via API"""
        msgt(self.test_20_log_entry_valid.__doc__)

        user = User.objects.get(username='******')

        # create a web client
        #
        client = Client()
        client.force_login(user)

        # create log entry url
        #
        url = reverse('view_create_log_entry_verbose')

        # retrieve log entry params
        #
        params = self.get_test_params_as_dict('log_params_01.json')

        # make the POST request
        #
        resp = client.post(url, params, content_type='application/json').json()

        print('resp', resp)
        self.assertTrue(resp['success'])
        self.assertTrue(resp['data']['id'])
Пример #16
0
    def test_140_GetProduceSolutionResults(self):
        """(140) Test GetProduceSolutionResults"""
        msgt(self.test_140_GetProduceSolutionResults.__doc__)
        # url and info for call
        #
        url = reverse('GetProduceSolutionResults')

        info = dict(request_id='request_id')

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        self.assertTrue(json_resp['success'])
        self.assertTrue('data' in json_resp)
        self.assertTrue('responses' in json_resp['data'])
        self.assertTrue(json_resp['data']['request_type'] == \
                        'GetProduceSolutionResults')
        self.assertTrue(json_resp['data']['responses']['count'] == 1)
        self.assertTrue(json_resp['data']['responses']['unread_count'] == 0)
        self.assertTrue('list' in json_resp['data']['responses'])
Пример #17
0
    def test_10_retrieve_history(self):
        """(10) Test the SearchHistoryUtil"""
        msgt(self.test_10_retrieve_history.__doc__)

        search_id = 1
        search_history_util = SearchHistoryUtil(search_id=search_id)

        self.assertEqual(search_history_util.has_error(), False)

        if search_history_util.has_error():
            print(f'Error found: {search_history_util.get_error_message()}')
            return

        json_history = search_history_util.get_finalized_history()

        for item in json_history:

            print('item', json.dumps(item, indent=4))
            return
            print('\n')
            print('-' * 40)
            req_text = (f"{item['request_type']} - (id: {item['id']})" f" ")
            print(req_text)
            for resp_item in item['response_list']:
                print((
                    f"  - (id: {resp_item['id']}) - (pipeline_id: {resp_item['pipeline_id']})"
                    f" - ({resp_item['status']})"))
Пример #18
0
    def test_100_ListPrimitives(self):
        """(100) Test ListPrimitives"""
        msgt(self.test_100_ListPrimitives.__doc__)
        # url and info for call
        #
        url = reverse('ListPrimitives')

        req_str = render_to_string('test_requests/req_ListPrimitives.json', {})

        response = self.client.post(url,
                                    req_str,
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        self.assertTrue(json_resp['success'])
        self.assertTrue('data' in json_resp)
        self.assertTrue('primitives' in json_resp['data'])
        self.assertEqual(len(json_resp['data']['primitives']), 3)

        # check the log
        self.assertEqual(BehavioralLogEntry.objects.filter(\
                            feature_id=ta2_static.LIST_PRIMITIVES).count(), 1)
Пример #19
0
    def test_40_good_end(self):
        """(40) Test the end session endpoint"""
        msgt(self.test_40_good_end.__doc__)

        # url and info for call
        #
        url = reverse('EndSession')
        info = dict(session_id='session_0')

        response = self.client.post(url,
                                    json.dumps(info),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        # status code 'OK'
        #
        self.assertEqual(json_resp['status']['code'], STATUS_VAL_OK)
    def test_030_retrieve_object(self):
        """(30) Test retrieval of particular object"""
        msgt(self.test_030_retrieve_object.__doc__)

        url = reverse('api_add_event_data_query')

        response = self.client.post(url,
                                    json.dumps(self.input_json1),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # get object

        url_get_obj = reverse('api_retrieve_event_data_query',
                              kwargs={'job_id': 1})
        response_list = self.client.get(url_get_obj)
        self.assertEqual(response_list.status_code, 200)
        # print("json res", response_list)
        # self.assertEqual(json.loads(response_list)['name'], 'query1')
        json_resp = response_list.json()

        obj = json_resp['data']

        self.assertEqual(obj['name'], 'query_1')
    def test_020_list(self):
        """(20) Test list all objects"""
        msgt(self.test_020_list.__doc__)

        url = reverse('api_add_event_data_query')

        response1 = self.client.post(url,
                                     json.dumps(self.input_json1),
                                     content_type="application/json")
        response2 = self.client.post(url,
                                     json.dumps(self.input_json2),
                                     content_type="application/json")

        # 200 response
        #
        self.assertEqual(response1.status_code, 200)
        self.assertEqual(response2.status_code, 200)

        # retrieve objects
        url_list = reverse('api_get_event_data_queries')

        response_list = self.client.get(url_list)

        self.assertEqual(response_list.status_code, 200)

        # convert to JSON
        #
        json_resp = response_list.json()
        obj = json_resp['data']
        print("--------------- data obj -------------", obj)
        # print('****json resp ****', json.loads(job)['data'])
        self.assertEqual(obj[0]['id'], 2)
        self.assertEqual(obj[1]['id'], 1)
        self.assertEqual(obj[0]['name'], 'query_2')
        self.assertEqual(obj[1]['name'], 'query_1')
Пример #22
0
    def test_020_SearchSolutions(self):
        """(20) Test SearchSolutions"""
        msgt(self.test_020_SearchSolutions.__doc__)
        # url and info for call
        #
        url = reverse('SearchSolutions')

        req_str = render_to_string(\
                    'test_requests/req_SearchSolutions.json',
                    dict(TA3TA2_API_VERSION=TA3TA2Util.get_api_version(),
                         TA3_GRPC_USER_AGENT=settings.TA3_GRPC_USER_AGENT))

        response = self.client.post(url,
                                    req_str,
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        print('json_resp', json_resp)

        self.assertTrue(json_resp['success'])
        self.assertTrue('data' in json_resp)
        self.assertTrue('searchId' in json_resp['data'])
Пример #23
0
    def test_10_good_get_results(self):
        """(10) Success. Test GetCreatePipelineResults endpoint used by UI"""
        msgt(self.test_10_good_get_results.__doc__)

        # url and info for call
        #
        url = reverse('GetCreatePipelineResults')

        info_dict = {
            "context": {
                "session_id": "session_0"
            },
            "pipeline_ids": ["pipeline_01", "pipeline_02"]
        }

        response = self.client.post(url,
                                    json.dumps(info_dict),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()
        #print('json_resp', json_resp[:200])
        #print(len(json_resp))

        # expect list of 6 responses
        #
        self.assertEqual(len(json_resp), 6)

        # status code 'OK'
        #
        fifth_resp = json_resp[4]
        self.assertEqual(fifth_resp['responseInfo']['status']['code'],
                         STATUS_VAL_OK)

        # progressInfo is "COMPLETED"
        #
        self.assertEqual(fifth_resp['progressInfo'], STATUS_VAL_COMPLETED)

        # There is a result uri
        #
        self.assertTrue('predictResultUri' in fifth_resp['pipelineInfo'])

        # There is a predictResultData
        #
        self.assertTrue('predictResultData' in fifth_resp['pipelineInfo'])

        # predictResultData contains
        #  the keys "success" and "data"
        #
        self.assertTrue(KEY_SUCCESS in\
                        fifth_resp['pipelineInfo']['predictResultData'])

        self.assertTrue(KEY_DATA in\
                        fifth_resp['pipelineInfo']['predictResultData'])
Пример #24
0
    def test_10_good_create(self):
        """(10) Test create pipelines endpoint used by UI"""
        msgt(self.test_10_good_create.__doc__)

        # url and info for call
        #
        url = reverse('CreatePipelines')

        info_dict = load_template_as_dict(
            'test_requests/req_create_pipeline.json')

        #response = self.client.post(url, format_info_for_request(info_dict))
        response = self.client.post(url,
                                    json.dumps(info_dict),
                                    content_type="application/json")

        # 200 response
        #
        self.assertEqual(response.status_code, 200)

        # convert to JSON
        #
        json_resp = response.json()

        # expect list of 6 responses
        #
        self.assertEqual(len(json_resp), 6)

        # status code 'OK'
        #
        fifth_resp = json_resp[4]
        self.assertEqual(fifth_resp['responseInfo']['status']['code'],
                         STATUS_VAL_OK)

        # progressInfo is "COMPLETED"
        #
        self.assertEqual(fifth_resp['progressInfo'], STATUS_VAL_COMPLETED)

        # There is a result uri
        #
        self.assertTrue('predictResultUri' in fifth_resp['pipelineInfo'])

        # There is a predictResultData
        #
        self.assertTrue('predictResultData' in fifth_resp['pipelineInfo'])

        # predictResultData contains
        #  the keys "success" and "data"
        #
        self.assertTrue(KEY_SUCCESS in\
                        fifth_resp['pipelineInfo']['predictResultData'])

        self.assertTrue(KEY_DATA in\
                        fifth_resp['pipelineInfo']['predictResultData'])
Пример #25
0
    def show_results(self):
        """print the results to the screen"""
        result_cnt = 0
        for resp_id, pipeline_result in self.pipeline_results.items():
            result_cnt += 1
            msgt('(%s) id: %s, steps: %s' % \
                 (result_cnt,
                  resp_id,
                  pipeline_result.get_num_pipeline_steps()))

            print('pipeline_result', type(pipeline_result))
            msg(pipeline_result.__str__())  #[:40])
Пример #26
0
    def test_10_get_version(self):
        """(10) Test start session endpoint used by UI"""
        msgt(self.test_10_get_version.__doc__)

        version = TA3TA2Util.get_api_version()

        self.assertTrue(version is not None)

        # 8 being YYYYMMDD, an actual version would be 2017.12.20
        self.assertTrue(len(version) > 8)

        # assume in century 20xx
        self.assertTrue(version[:2] == '20')
Пример #27
0
    def test_010_markup_image(self):
        """(10) Test markup image"""
        msgt(self.test_010_markup_image.__doc__)

        spec = self.get_test_spec()

        info = markup_image(spec, self.get_output_dir())
        print(info)

        self.assertEqual(info.get(KEY_SUCCESS), True)
        self.assertTrue(KEY_DATA in info)

        self.clean_up_file(info)
Пример #28
0
    def test_10_list_workspaces_not_logged_in(self):
        """(10) List workspaces, not logged in"""
        msgt(self.test_10_list_workspaces_not_logged_in.__doc__)

        # create a web client
        client = Client()

        # retrieve the workspace
        url = reverse('view_latest_raven_configs',
                      kwargs=dict())

        resp = client.get(url).json()

        self.assertTrue(not resp['success'])
Пример #29
0
    def test_10_log_entry_not_logged_in(self):
        """(10) List workspaces, not logged in"""
        msgt(self.test_10_log_entry_not_logged_in.__doc__)

        # create a web client
        client = Client()

        # create log entry url
        url = reverse('view_create_log_entry')

        params = self.get_test_params_as_dict('log_params_01.json')

        resp = client.post(url, params, content_type='application/json').json()

        print('resp', resp)
        self.assertTrue(not resp['success'])
Пример #30
0
    def run_process(self):
        """
        Retrieve Pipeline results based on KEY_SOLUTION_ID
        """
        params = dict(stored_request__request_type='GetSearchSolutionsResults')

        stored_responses = StoredResponse.objects.filter(**params)

        resp_cnt = stored_responses.count()
        if resp_cnt == 0:
            user_msg = ('No StoredResponse objects found of type'
                        ' "GetSearchSolutionsResults"')
            msgt(user_msg)
            self.add_error_message(user_msg)
            return

        # Iterate through GetSearchSolutionsResults,
        # looking instances of solutionId
        #
        loop_cnt = 0
        for sr in stored_responses:
            loop_cnt += 1
            if not sr.response:
                user_msg = 'No response found'
                self.pipeline_results[sr.id] = \
                    PipelineSteps.create_with_error(user_msg)
                return

            if not KEY_SOLUTION_ID in sr.response:
                user_msg = 'No "%s" found in the response' % KEY_SOLUTION_ID
                self.pipeline_results[sr.id] = \
                    PipelineSteps.create_with_error(user_msg)
                return

            solution_id = sr.response[KEY_SOLUTION_ID]
            if not solution_id:
                user_msg = 'Blank "%s" found in the response' % KEY_SOLUTION_ID
                self.pipeline_results[sr.id] = \
                    PipelineSteps.create_with_error(user_msg)
                return

            self.pipeline_results[sr.id] = self.run_describe_solution(
                solution_id)

            if self.has_error():
                # In case there is a timeout b/c a TA2 is not available
                break