Ejemplo n.º 1
0
 def test_get_hash_success(self, m_get):
     mock_resp = Mock()
     mock_resp.ok = True
     mock_resp.text = "the_hash"
     m_get.return_value = mock_resp
     result = util.get_gitbuilder_hash()
     assert result == "the_hash"
Ejemplo n.º 2
0
 def test_version_strip_v(self):
     resp = Mock()
     resp.ok = True
     resp.text = "v0.90.0"
     self.m_get_response.return_value = resp
     super(TestGitbuilderProject, self)\
         .test_get_package_version_found()
Ejemplo n.º 3
0
 def test_download_graphs(self):
     dest_dir = '/fake/path'
     obj = self.klass(
         hosts=['host1'],
         time_from='now-3h',
         dest_dir=dest_dir,
     )
     _format = obj.graph_defaults.get('format')
     with patch('teuthology.task.pcp.requests.get', create=True) as m_get:
         m_resp = Mock()
         m_resp.ok = True
         m_get.return_value = m_resp
         with patch('teuthology.task.pcp.open', create=True) as m_open:
             m_open.return_value = MagicMock(spec=file)
             obj.download_graphs()
     expected_filenames = []
     for metric in obj.metrics:
         expected_filenames.append(
             "{}.{}".format(
                 os.path.join(
                     dest_dir,
                     obj._sanitize_metric_name(metric),
                 ),
                 _format,
             )
         )
     graph_filenames = []
     for metric in obj.graphs.keys():
         graph_filenames.append(obj.graphs[metric]['file'])
     assert sorted(graph_filenames) == sorted(expected_filenames)
Ejemplo n.º 4
0
    def setUp(self):
        # mock request object
        request = Request()
        request.method = "GET"
        request.url = "http://example.com/"
        request.params = {}
        request.data = {}
        request.params_and_data = {}
        self.request = request

        # mock response object
        response = Mock()
        response.content = "access_token=321"
        response.headers = {"content-type": "text/html; charset=UTF-8"}
        response.ok = True
        response.status_code = 200
        self.response = response

        # mock raise_for_status with an error
        def raise_for_status():
            raise Exception("Response not OK!")

        self.raise_for_status = raise_for_status

        # mock hook object
        hook = Mock()
        hook.consumer_key = "123"
        hook.consumer_secret = "456"
        hook.access_token = "321"
        hook.access_token_secret = "654"
        self.hook = hook
Ejemplo n.º 5
0
def __one_bad_two_ok(*args):
    response = Mock()
    response.ok = args[0] == 'http://example.com/oembed2'
    response.text = 'hello, world'
    response.headers = {'content-type': 'application/json'}

    return response
Ejemplo n.º 6
0
def generic_successful_response():
    mock_network_response = Mock(DefaultNetworkResponse)
    mock_network_response.content = b'{"message": "success"}'
    mock_network_response.status_code = 200
    mock_network_response.ok = True
    mock_network_response.raw = Mock()
    return mock_network_response
Ejemplo n.º 7
0
Archivo: base.py Proyecto: 10to8/rauth
 def setUp(self):
     response = Mock()
     response.content = json.dumps({'status': 'ok'})
     response.headers = {'Content-Type': 'application/json'}
     response.ok = True
     response.status_code = requests.codes.ok
     self.response = response
Ejemplo n.º 8
0
 def test_package_version_for_hash(self, m_get):
     mock_resp = Mock()
     mock_resp.ok = True
     mock_resp.text = "the_version"
     m_get.return_value = mock_resp
     result = util.package_version_for_hash("hash")
     assert result == "the_version"
Ejemplo n.º 9
0
 def test_get_hash_fail(self, m_get, m_get_gitbuilder_url):
     m_get_gitbuilder_url.return_value = "http://baseurl.com"
     mock_resp = Mock()
     mock_resp.ok = False
     m_get.return_value = mock_resp
     result = suite.get_hash()
     assert result is None
Ejemplo n.º 10
0
def non_json_response():
    mock_network_response = Mock(DefaultNetworkResponse)
    mock_network_response.content = b''
    mock_network_response.ok = True
    mock_network_response.status_code = 200
    mock_network_response.json.side_effect = ValueError('No JSON object could be decoded')
    return mock_network_response
Ejemplo n.º 11
0
    def setUp(self):
        # mock request object
        request = Request()
        request.method = 'GET'
        request.url = 'http://example.com/'
        request.params = {}
        request.data = {}
        request.params_and_data = {}
        self.request = request

        # mock response object
        response = Mock()
        response.content = 'access_token=321'
        response.headers = {'content-type': 'text/html; charset=UTF-8'}
        response.ok = True
        response.status_code = 200
        self.response = response

        # mock raise_for_status with an error
        def raise_for_status():
            raise Exception('Response not OK!')

        self.raise_for_status = raise_for_status

        # mock hook object
        hook = Mock()
        hook.consumer_key = '123'
        hook.consumer_secret = '456'
        hook.access_token = '321'
        hook.access_token_secret = '654'
        self.hook = hook
    def test_api_get_fail(self, mock_login, mock_get, mock_headers):
        """
        Test ._api_get() raises an exception
        """
        mock_login.return_value = self.account_id
        mock_headers.return_value = {}

        mock_response = Mock(spec=requests.Response)
        mock_response.status_code = 500
        mock_response.text = "Server error"
        mock_response.ok = False

        mock_get.return_value = mock_response

        url = 'https://logentries.com/app/{account_id}/rest/tag'.format(account_id=self.account_id)

        alert = SpecialAlertBase(self.username, self.password)

        with self.assertRaises(ServerException):
            alert._api_get(
                url=url,
                data={'k': 'v'}
            )

        mock_get.assert_called_once_with(
            alert.session,
            url=url,
            headers={},
            data={'k': 'v'}
        )
Ejemplo n.º 13
0
 def test_get_package_sha1_fetched_found(self):
     resp = Mock()
     resp.ok = True
     resp.json.return_value = [dict(sha1='the_sha1')]
     self.m_get.return_value = resp
     super(TestShamanProject, self)\
         .test_get_package_sha1_fetched_found()
Ejemplo n.º 14
0
    def test_wait_for_snapshot_status_good_response_code_config_wait_period(
            self):

        client = Mock(spec=VolumesClient)

        config = Mock(spec=VolumesAPIConfig)
        config.snapshot_status_poll_frequency = 1

        snapshot_model = Mock(spec=VolumeSnapshotResponse)
        snapshot_model.status = self.defaults.expected_status

        response = Mock(spec=Response)
        response.ok = True
        response.entity = snapshot_model

        client.get_snapshot_info = MagicMock(
            return_value=response)

        behavior = VolumesAPI_Behaviors(client, config)

        resp = behavior.wait_for_snapshot_status(
            self.defaults.snapshot_name, self.defaults.expected_status,
            self.defaults.timeout)

        self.assertIsNone(resp)
    def test_load_post(self, RequestsGetMock):

        # set up a mock response with stubbed json to simulate the API
        def read_post_json():
            with open(os.path.join(os.path.dirname(__file__), "data", "post.json")) as post_json_file:
                return json.load(post_json_file)

        mock_response = Mock(Response)
        mock_response.ok = True
        mock_response.text = "some text"
        mock_response.json = read_post_json

        RequestsGetMock.return_value = mock_response

        # call we're testing
        post = self.loader.load_post(1)

        # some validations
        self.assertIsInstance(post, Post)
        self.assertEqual(post.wp_id, 1)
        self.assertEqual(post.title, "This is a Test Post")
        self.assertEqual(post.author.name, "testauthor")
        self.assertEqual(post.categories.first().name, "News")
        self.assertEqual(post.tags.first().name, "Testing")
        self.assertEqual(post.attachments.first().url, "https://test.local/testpost.jpg")
Ejemplo n.º 16
0
 def test_arbitrary_member(self, mock_request):
     mock_response = Mock()
     mock_response.ok = True
     mock_response.content = json.dumps({"short_codes": []})
     mock_request.return_value = mock_response
     self.assertEqual([], self.client.sms.short_codes.list())
     mock_request.assert_called_once_with("GET", ANY, params=ANY, auth=AUTH, timeout=sentinel.timeout)
Ejemplo n.º 17
0
 def test_get_package_sha1_fetched_found(self):
     resp = Mock()
     resp.ok = True
     resp.text = "the_sha1"
     self.m_get.return_value = resp
     super(TestGitbuilderProject, self)\
         .test_get_package_sha1_fetched_found()
Ejemplo n.º 18
0
def test_revoke_sends_revoke_request(
        client_id,
        client_secret,
        mock_network_layer,
        access_token,
        refresh_token,
        expected_token_to_revoke,
):
    mock_network_response = Mock()
    mock_network_response.ok = True
    mock_network_layer.request.return_value = mock_network_response
    oauth = OAuth2(
        client_id=client_id,
        client_secret=client_secret,
        access_token=access_token,
        refresh_token=refresh_token,
        network_layer=mock_network_layer,
    )
    oauth.revoke()
    mock_network_layer.request.assert_called_once_with(
        'POST',
        '{0}/revoke'.format(API.OAUTH2_API_URL),
        data={
            'client_id': client_id,
            'client_secret': client_secret,
            'token': expected_token_to_revoke,
        },
        access_token=access_token,
    )
    assert oauth.access_token is None
Ejemplo n.º 19
0
    def test_wait_for_volume_status_good_response_code_bad_status(self):
        volume_name = 'mock_volume'
        expected_status = 'available'
        timeout = 10
        poll_rate = 2

        client = Mock(spec=VolumesClient)

        config = Mock(spec=VolumesAPIConfig)
        config.volume_status_poll_frequency = 1

        volume_model = Mock(spec=VolumeResponse)
        volume_model.status = expected_status

        response = Mock(spec=Response)
        response.ok = True
        response.entity = volume_model

        client.get_volume_info = MagicMock(
            return_value=response)

        behavior = VolumesAPI_Behaviors(client, config)

        resp = behavior.wait_for_volume_status(
            volume_name, expected_status, timeout, poll_rate=poll_rate)

        self.assertIsNone(resp)
Ejemplo n.º 20
0
    def test_wait_for_volume_status_good_response_code_configured_poll_rate(
            self):

        client = Mock(spec=VolumesClient)

        config = Mock(spec=VolumesAPIConfig)
        config.volume_status_poll_frequency = 1

        volume_model = Mock(spec=VolumeResponse)
        volume_model.status = self.defaults.expected_status

        response = Mock(spec=Response)
        response.ok = True
        response.entity = volume_model

        client.get_volume_info = MagicMock(
            return_value=response)

        behavior = VolumesAPI_Behaviors(client, config)

        resp = behavior.wait_for_volume_status(
            self.defaults.volume_name, self.defaults.expected_status,
            self.defaults.timeout)

        self.assertIsNone(resp)
Ejemplo n.º 21
0
    def test_wait_for_snapshot_status_good_response_and_entity_bad_status(
            self):
        recieved_status = 'error'

        client = Mock(spec=VolumesClient)

        config = Mock(spec=VolumesAPIConfig)
        config.snapshot_status_poll_frequency = 1

        snapshot_model = Mock(spec=VolumeSnapshotResponse)
        snapshot_model.status = recieved_status

        response = Mock(spec=Response)
        response.ok = True
        response.entity = snapshot_model

        client.get_snapshot_info = MagicMock(
            return_value=response)

        behavior = VolumesAPI_Behaviors(client, config)

        with self.assertRaises(VolumesAPIBehaviorException):
            behavior.wait_for_snapshot_status(
                self.defaults.snapshot_name, self.defaults.expected_status,
                self.defaults.timeout, poll_rate=self.defaults.poll_rate)
Ejemplo n.º 22
0
def test_make_twilio_request_bad_data(mock):
    resp = Mock()
    resp.ok = False
    mock.return_value = resp

    url = "http://random/url"
    make_twilio_request("POST", url)
    mock.assert_called_with("POST", "http://random/url.json", headers=post_headers)
Ejemplo n.º 23
0
 def test_get_branch_info(self, m_get):
     mock_resp = Mock()
     mock_resp.ok = True
     mock_resp.json.return_value = "some json"
     m_get.return_value = mock_resp
     result = suite.get_branch_info("teuthology", "master")
     m_get.assert_called_with("https://api.github.com/repos/ceph/teuthology/git/refs/heads/master")
     assert result == "some json"
Ejemplo n.º 24
0
def network_response_with_missing_tokens(request):
    mock_network_response = Mock(DefaultNetworkResponse)
    mock_network_response.ok = True
    json_dict = {}
    for key in request.param:
        json_dict[key] = 'fake_token'
    mock_network_response.json.return_value = json_dict
    return mock_network_response
Ejemplo n.º 25
0
 def test_get_hash_success(self, m_get, m_get_gitbuilder_url):
     m_get_gitbuilder_url.return_value = "http://baseurl.com"
     mock_resp = Mock()
     mock_resp.ok = True
     mock_resp.text = "the_hash"
     m_get.return_value = mock_resp
     result = suite.get_hash()
     m_get.assert_called_with("http://baseurl.com/ref/master/sha1")
     assert result == "the_hash"
Ejemplo n.º 26
0
 def test_package_version_for_hash(self, m_get, m_get_gitbuilder_url):
     m_get_gitbuilder_url.return_value = "http://baseurl.com"
     mock_resp = Mock()
     mock_resp.ok = True
     mock_resp.text = "the_version"
     m_get.return_value = mock_resp
     result = suite.package_version_for_hash("hash")
     m_get.assert_called_with("http://baseurl.com/sha1/hash/version")
     assert result == "the_version"
Ejemplo n.º 27
0
def test_should_raise_error_on_all_request_errors():
    with patch('requests.get') as mock_get, \
            pytest.raises(consumer.PyEmbedConsumerError):
        response = Mock()
        response.ok = False
        response.text = 'hello, world'
        mock_get.return_value = response

        consumer.get_first_oembed_response(['http://example.com/oembed1', 'http://example.com/oembed2'])
Ejemplo n.º 28
0
 def test_get_package_version_not_found(self, m_get_response):
     rem = self._get_remote()
     ctx = dict(foo="bar")
     resp = Mock()
     resp.ok = False
     m_get_response.return_value = resp
     gp = self.klass("ceph", {}, ctx=ctx, remote=rem)
     with pytest.raises(VersionNotFoundError):
         gp.version
Ejemplo n.º 29
0
def generic_successful_response():
    mock_network_response = Mock(Response)
    content = '{"message": "success"}'
    mock_network_response.content = content.encode('utf-8')
    mock_network_response.status_code = 200
    mock_network_response.ok = True
    mock_network_response.raw = Mock()
    mock_network_response.json.return_value = json.loads(content)
    return mock_network_response
Ejemplo n.º 30
0
 def get_response(limit, offset):
     items_json, items = mock_items
     mock_box_response = Mock(BoxResponse)
     mock_network_response = Mock(DefaultNetworkResponse)
     mock_box_response.network_response = mock_network_response
     mock_box_response.json.return_value = mock_json = {'entries': items_json[offset:limit + offset]}
     mock_box_response.content = json.dumps(mock_json).encode()
     mock_box_response.status_code = 200
     mock_box_response.ok = True
     return mock_box_response, items[offset:limit + offset]
Ejemplo n.º 31
0
 def test_get_package_version_not_found(self, m_get_config_value,
                                        m_config, m_get_response):
     m_config.baseurl_template = 'http://{host}/{proj}-{pkg_type}-{dist}-{arch}-{flavor}/{uri}'
     m_config.gitbuilder_host = "gitbuilder.ceph.com"
     m_get_config_value.return_value = None
     rem = self._get_remote()
     ctx = dict(foo="bar")
     resp = Mock()
     resp.ok = False
     m_get_response.return_value = resp
     gp = packaging.GitbuilderProject("ceph", {}, ctx=ctx, remote=rem)
     with pytest.raises(VersionNotFoundError):
         gp.version
Ejemplo n.º 32
0
 def test_get_package_sha1_fetched_found(self, m_get, m_get_config_value,
                                         m_config):
     m_config.baseurl_template = 'http://{host}/{proj}-{pkg_type}-{dist}-{arch}-{flavor}/{uri}'
     m_config.gitbuilder_host = "gitbuilder.ceph.com"
     m_get_config_value.return_value = None
     resp = Mock()
     resp.ok = True
     resp.text = "the_sha1"
     m_get.return_value = resp
     rem = self._get_remote()
     ctx = dict(foo="bar")
     gp = packaging.GitbuilderProject("ceph", {}, ctx=ctx, remote=rem)
     assert gp.sha1 == "the_sha1"
Ejemplo n.º 33
0
 def test_get_sl_type(self, mock_get):
     """Test get_sl_type"""
     sl_type = {
         'id': 1,
         'name': 'security_fixes',
         'description': 'security_fixes',
     }
     mock_rv = Mock()
     mock_rv.ok = True
     mock_rv.json.return_value = {'count': 1, 'results': [sl_type]}
     mock_get.return_value = mock_rv
     rv = utils.get_sl_type('http://pdc.local/', 'securty_fixes')
     self.assertEqual(rv, sl_type)
Ejemplo n.º 34
0
def generic_successful_request_response():
    mock_request_response = Mock(requests.Response(),
                                 headers=dict([('header{0}'.format(i),
                                                'value{0}'.format(i))
                                               for i in range(4)]))
    _set_content_and_json_from_json(mock_request_response,
                                    json_value=dict([('key{0}'.format(i),
                                                      'value{0}'.format(i))
                                                     for i in range(8)]))
    mock_request_response.status_code = 200
    mock_request_response.ok = True
    mock_request_response.request = Mock()
    return mock_request_response
Ejemplo n.º 35
0
 def test_get_sl_type_pdc_error(self, mock_request_get):
     """Test get_sl_type when PDC errors"""
     mock_rv = Mock()
     mock_rv.ok = False
     mock_rv.text = 'Some error'
     mock_request_get.return_value = mock_rv
     try:
         utils.get_sl_type('http://pdc.local/', 'securty_fixes')
         assert False, 'rpkgError not raised'
     except rpkgError as error:
         expected_error = ('The following error occurred while validating '
                           'the passed in service level in PDC: Some error')
         self.assertEqual(str(error), expected_error)
Ejemplo n.º 36
0
    def test_create_container(self):
        response = Mock(spec=requests.Response)
        response.ok = True

        client = Mock(spec=obj_client.ObjectStorageAPIClient)
        client.create_container = MagicMock(return_value=response)

        config = Mock(spec=obj_config.ObjectStorageAPIConfig)

        behavior = behaviors.ObjectStorageAPI_Behaviors(client, config)
        behavior.create_container(test_client.VALID_CONTAINER_NAME)
        client.create_container.assert_called_with(
            test_client.VALID_CONTAINER_NAME, headers={})
Ejemplo n.º 37
0
def get_oembed_urls(fixture='valid_oembed.html', oembed_format=None, ok=True):
    with patch('requests.get') as mock_get:
        response = Mock()
        response.ok = ok
        response.text = open('pyembed/core/test/fixtures/auto_discovery/' +
                             fixture).read()
        mock_get.return_value = response

        result = list(discovery.AutoDiscoverer().get_oembed_urls(
            'http://example.com', oembed_format))

        mock_get.assert_called_with('http://example.com')
        return result
Ejemplo n.º 38
0
def empty_events_response(final_stream_position):
    # pylint:disable=redefined-outer-name
    mock_box_response = Mock(BoxResponse)
    mock_network_response = Mock(DefaultNetworkResponse)
    mock_box_response.network_response = mock_network_response
    mock_box_response.json.return_value = mock_json = {
        'next_stream_position': final_stream_position,
        'entries': []
    }
    mock_box_response.content = json.dumps(mock_json).encode()
    mock_box_response.status_code = 200
    mock_box_response.ok = True
    return mock_box_response
Ejemplo n.º 39
0
    def get_mocks(self):
        client = Mock(spec=VolumesClient)
        config = Mock(spec=VolumesAPIConfig)
        volume_model = Mock(spec=VolumeResponse)
        response = Mock(spec=Response)

        config.volume_status_poll_frequency = 1
        volume_model.status = self.defaults.expected_status
        response.ok = True
        response.entity = volume_model
        client.get_volume_info = MagicMock(return_value=response)

        return (client, config, volume_model, response)
Ejemplo n.º 40
0
def unsuccessful_jwt_response(box_datetime, status_code, error_description,
                              include_date_header, error_code):
    headers = {
        'Date': box_datetime.strftime('%a, %d %b %Y %H:%M:%S %Z')
    } if include_date_header else {}
    unsuccessful_response = Mock(requests.Response(), headers=headers)
    unsuccessful_response.json.return_value = {
        'error_description': error_description,
        'error': error_code
    }
    unsuccessful_response.status_code = status_code
    unsuccessful_response.ok = False
    return unsuccessful_response
Ejemplo n.º 41
0
 def get_response(limit, offset):
     mock_box_response = Mock(BoxResponse)
     mock_network_response = Mock(DefaultNetworkResponse)
     mock_box_response.network_response = mock_network_response
     mock_box_response.json.return_value = mock_json = {
         'entries': entries[offset:limit + offset],
         'total_count': len(entries),
         'limit': limit,
     }
     mock_box_response.content = json.dumps(mock_json).encode()
     mock_box_response.status_code = 200
     mock_box_response.ok = True
     return mock_box_response
Ejemplo n.º 42
0
    def test_create_container(self):
        response = Mock(spec=Response)
        response.ok = True

        client = Mock(spec=ObjectStorageAPIClient)
        client.create_container = MagicMock(return_value=response)

        config = Mock(spec=ObjectStorageAPIConfig)

        behavior = ObjectStorageAPI_Behaviors(client, config)
        behavior.create_container(client_test.VALID_CONTAINER_NAME)
        client.create_container.assert_called_with(
            client_test.VALID_CONTAINER_NAME)
Ejemplo n.º 43
0
    def test_requests_returns_not_ok(self):

        req = test_bse_utils.requests = Mock()

        mock_not_ok = Mock()
        mock_not_ok.ok = False
        req.get = Mock(return_value=mock_not_ok)

        bse_utils_gen = test_bse_utils.bse_get_all_stocks_list(start=0,
                                                               count=-1)
        with self.assertRaises(StopIteration) as context:
            next(bse_utils_gen)

        self.assertTrue(context)
Ejemplo n.º 44
0
    def test_read_yield_data_normally(self, get):
        rv = Mock()
        rv.ok = True
        rv.json.side_effect = [{
            'results': ['item1', 'item2'],
            'next': 'http://localhost/?page=2'
        }, {
            'results': ['item3'],
            'next': None
        }]
        get.return_value = rv

        result = utils.query_pdc('http://localhost/', 'endpoint', {})
        self.assertEqual(['item1', 'item2', 'item3'], list(result))
Ejemplo n.º 45
0
 def test_generate_html_static(self):
     obj = self.klass(
         hosts=['host1'],
         time_from='now-3h',
         dest_dir='/fake/path',
     )
     with patch('teuthology.task.pcp.requests.get', create=True) as m_get:
         m_resp = Mock()
         m_resp.ok = True
         m_get.return_value = m_resp
         with patch('teuthology.task.pcp.open', mock_open(), create=True):
             obj.download_graphs()
     html = obj.generate_html(mode='static')
     assert config.pcp_host not in html
Ejemplo n.º 46
0
    def test_download_chunked_file(self, client, rest_client, target_file,
                                   target_file_id):
        file_data = b64encode(target_file.read())

        client._check_chunked_file_validity = Mock(
            return_value=(True, {
                "file_id": target_file_id,
                "number_of_chunks": 1
            }))
        response = Mock()
        response.ok = True
        response.json = Mock(return_value={"data": file_data})
        rest_client.get_chunked_file.return_value = response
        byte_obj = client.download_chunked_file("file_id")
        assert byte_obj.read() == b64decode(file_data)
Ejemplo n.º 47
0
def mock_coverage_rule():
    """
    rule_coverage mock value
    """
    mock_rep = Mock()
    mock_rep.ok = True
    mock_rep.json.return_value = {
        "coverage": {
            "evolution": {
                "translation_platform": {
                    "German": {
                        "Total": 5600,
                        "Translated": 5482,
                        "Untranslated": 102,
                        "Remaining": 1.82
                    },
                },
                "build_system": {
                    "f30": {
                        "German": {
                            "Total": 1841,
                            "Translated": 1841,
                            "Untranslated": 0,
                            "Remaining": 0
                        },
                    }
                }
            },
            "libuser": {
                "translation_platform": {
                    "German": {
                        "Total": 301,
                        "Translated": 301,
                        "Untranslated": 0,
                        "Remaining": 0
                    },
                },
                "build_system": {
                    "f30": {
                        "Statistics": "Not Synced with Build System for f30"
                    }
                }
            },
            "release": "fedora-30",
            "coverage_rule": "rhinstaller"
        }
    }
    return mock_rep
Ejemplo n.º 48
0
    def testPassThrough(self, mock_request):
        mock_response = Mock()
        mock_response.ok = True,
        mock_response.content = json.dumps({'key': 'value'})
        mock_request.return_value = mock_response

        assert_equal(self.r.timeout, sentinel.timeout)
        assert_equal((mock_response, {
            'key': 'value'
        }), self.r.request('GET', base_uri))

        mock_request.assert_called_once_with('GET',
                                             base_uri + '.json',
                                             headers=ANY,
                                             timeout=sentinel.timeout,
                                             auth=ANY)
Ejemplo n.º 49
0
    def test_release_exists_current(self, mock_get):
        mock_rv = Mock()
        mock_rv.ok = True
        mock_rv.json.return_value = {
            'name': 'F30',
            'long_name': 'Fedora 30',
            'version': '30',
            'branch': 'f30',
            'state': 'current',  # this item is only important for the test
        }
        mock_get.return_value = mock_rv

        config = Mock()
        config.get.return_value = 'https://service_url/releases/F30'

        rv = utils.get_fedora_release_state(config, 'fedpkg', 'F30')
        self.assertEqual(rv, 'current')
Ejemplo n.º 50
0
 def test_get_release_branches(self, mock_request_get):
     """Test that get_release_branches returns all the active Fedora release
     branches.
     """
     mock_rv = Mock()
     mock_rv.ok = True
     # This abbreviated data returned from the product-versions PDC API
     mock_rv.json.return_value = {
         'count':
         7,
         'next':
         None,
         'previous':
         None,
         'results': [{
             'short': 'epel',
             'version': '6'
         }, {
             'short': 'epel',
             'version': '7'
         }, {
             'short': 'fedora',
             'version': '25'
         }, {
             'short': 'fedora',
             'version': '26'
         }, {
             'short': 'fedora',
             'version': '27'
         }, {
             'short': 'fedora',
             'version': '28'
         }, {
             'short': 'fedora',
             'version': 'rawhide'
         }]
     }
     mock_request_get.return_value = mock_rv
     expected = set(['el6', 'epel7', 'f25', 'f26', 'f27', 'f28'])
     expected = {
         'epel': ['el6', 'epel7'],
         'fedora': ['f25', 'f26', 'f27', 'f28'],
     }
     actual = utils.get_release_branches('http://pdc.local')
     self.assertEqual(expected, actual)
Ejemplo n.º 51
0
    def membership_responses(total, page_size, hidden_in_batch=None):
        offset = 0
        for number_entries in number_entries_per_response(total, page_size, hidden_in_batch):
            entries = take(mock_membership_dict_stream, number_entries)

            mock_box_response = Mock(BoxResponse)
            mock_network_response = Mock(DefaultNetworkResponse)
            mock_box_response.network_response = mock_network_response
            mock_box_response.json.return_value = {
                'entries': entries,
                'total_count': total,
                'offset': offset,
                'limit': page_size,
            }
            offset += number_entries
            mock_box_response.status_code = 200
            mock_box_response.ok = True
            yield mock_box_response
Ejemplo n.º 52
0
def test_should_find_oembed_urls():
    response = Mock()
    response.ok = True

    with open('pyembed/core/test/fixtures/static_discovery/valid.json') as f:
        response.json.return_value = json.load(f)

    with patch('requests.get') as mock_get:
        mock_get.return_value = response

        discoverer = discovery.UrlDiscoverer(
            'http://example.com/providers.json')
        result = discoverer.get_oembed_urls('http://example.com/simple/123')
        assert list(result) == [
            'http://example.com/simple/oembed?url=http%3A%2F%2Fexample.com%2Fsimple%2F123&format=json',
            'http://example.com/simple/oembed?url=http%3A%2F%2Fexample.com%2Fsimple%2F123&format=xml'
        ]

        mock_get.assert_called_with('http://example.com/providers.json')
Ejemplo n.º 53
0
def mock_package_status():
    """
    package_status mock value
    """
    mock_rep = Mock()
    mock_rep.ok = True
    mock_rep.json.return_value = {
        "systemd": {
            "translation_stats": {
                "Upstream": {
                    "French": 100,
                    "Japanese": 0.0,
                    "Spanish": 100,
                    "Russian": 100,
                    "German": 100
                }
            },
            "percentage_calculated_on": "Messages"
        }
    }
    return mock_rep
Ejemplo n.º 54
0
    def get_mocks(self):
        client = Mock(spec=VolumesClient)
        volume_model = Mock(spec=VolumeResponse)
        volume_create_response = Mock(spec=Response)
        volume_model.id_ = "mock"
        volume_create_response.entity = volume_model
        volume_create_response.ok = True
        client.create_volume = MagicMock(return_value=volume_create_response)

        config = Mock(spec=VolumesAPIConfig)
        config.serialize_format = "json"
        config.deserialize_format = "json"
        config.max_volume_size = 1024
        config.min_volume_size = 1
        config.volume_status_poll_frequency = 5
        config.volume_create_min_timeout = 1
        config.volume_create_max_timeout = 10
        config.volume_create_wait_per_gigabyte = 1
        config.volume_create_base_timeout = 0

        return (client, config, volume_model, volume_create_response)
Ejemplo n.º 55
0
def mock_release_workload_detail():
    """
    release_workload_detail mock value
    """
    mock_rep = Mock()
    mock_rep.ok = True
    mock_rep.json.return_value = {
        "German": {
            "anaconda": {
                "Total": 1208,
                "Translated": 1199,
                "Untranslated": 9,
                "Remaining": 0.75
            },
            "abrt": {
                "Total": 476,
                "Translated": 476,
                "Untranslated": 0,
                "Remaining": 0.0
            },
            "Calculated on": "Messages"
        },
        "Japanese": {
            "abrt": {
                "Total": 476,
                "Translated": 390,
                "Untranslated": 86,
                "Remaining": 18.07
            },
            "python-meh": {
                "Total": 23,
                "Translated": 20,
                "Untranslated": 3,
                "Remaining": 13.04
            },
            "Calculated on": "Messages"
        },
        "Release": "fedora-27",
    }
    return mock_rep
Ejemplo n.º 56
0
def test_revoke_sends_revoke_request(
    client_id,
    client_secret,
    mock_box_session,
    access_token,
    oauth,
    expected_token_to_revoke,
):
    mock_network_response = Mock()
    mock_network_response.ok = True
    mock_box_session.request.return_value = mock_network_response
    oauth.revoke()
    mock_box_session.request.assert_called_once_with(
        'POST',
        '{0}/revoke'.format(API.OAUTH2_API_URL),
        data={
            'client_id': client_id,
            'client_secret': client_secret,
            'token': expected_token_to_revoke,
        },
        access_token=access_token,
    )
    assert oauth.access_token is None
Ejemplo n.º 57
0
def mock_package_status_health():
    """
    package_status_health mock value
    """
    mock_rep = Mock()
    mock_rep.ok = True
    mock_rep.json.return_value = {
     "abrt": {
        "fedora-30": {
            "Arabic": 2,
            "Basque": 3,
            "Esperanto": 7,
            "Friulian": 24,
            "Serbian": 14,
            "Turkish": 13,
            "Urdu": 3
        },
        "fedora-31": {
            "Friulian": 24
        }
      }
    }
    return mock_rep
Ejemplo n.º 58
0
def mock_release_status():
    """
    release_status mock value
    """
    mock_rep = Mock()
    mock_rep.ok = True
    mock_rep.json.return_value = {
        "fedora-27": {
            "anaconda": {
                "Total": 12080,
                "Translated": 11191,
                "Untranslated": 876,
                "Remaining": 7.25
            },
            "abrt": {
                "Total": 4760,
                "Translated": 4495,
                "Untranslated": 262,
                "Remaining": 5.5
            },
            "Calculated on": "Messages"
        }
    }
    return mock_rep
Ejemplo n.º 59
0
        def get_response(limit, marker):
            mock_box_response = Mock(BoxResponse)
            mock_network_response = Mock(DefaultNetworkResponse)
            mock_box_response.network_response = mock_network_response

            mock_json = {}
            # The marker string should be of format: "marker_i", where i is the offset. Parse that out.
            # If the marker is None, then begin paging from the start of the entries.
            offset = 0
            if marker is not None:
                offset = int(marker.split('_')[1])
            mock_json['entries'] = entries[offset:limit + offset]

            # A next_marker is only returned if there are more pages left.
            if (offset + limit) < len(entries):
                mock_json['next_marker'] = 'marker_{0}'.format(offset + limit)
            elif next_marker_value_for_last_page is not self.NO_NEXT_MARKER:
                mock_json['next_marker'] = next_marker_value_for_last_page

            mock_box_response.json.return_value = mock_json
            mock_box_response.content = json.dumps(mock_json).encode()
            mock_box_response.status_code = 200
            mock_box_response.ok = True
            return mock_box_response
Ejemplo n.º 60
0
 def test_get_package_sha1_fetched_not_found(self):
     resp = Mock()
     resp.ok = False
     self.m_get.return_value = resp
     super(TestGitbuilderProject, self)\
         .test_get_package_sha1_fetched_not_found()