Ejemplo n.º 1
0
    def test_undo(self):
        """
        Does the undo disable the interface?
        """
        connection = MagicMock(name='connection')
        html = MagicMock(name='html')
        connection.return_value = html
        html.text = open('radio_asp.html').read()
        command = EnableInterface(connection=connection)        

        command.band = 5
        command()

        html.text = open('radio_5_asp.html').read()

        command.undo()
        query_call = call(data={'wl_unit':'1'})
        calls = [query_call,
                 call(data={'action':'Apply',
                        'wl_unit':'1',
                        'wl_radio':'1'}),
                            call(data ={'action':'Apply',
                        'wl_unit':'1',
                        'wl_radio':'0'})]
        self.assertEqual(connection.mock_calls, calls)
        self.command.previous_state = 'Enabled'

        # the disable checks the state so we need to change the html so it is Disabled
        #self.html.text = open('radio_5_asp.html').read()
        #self.command.undo()
        #self.assertEqual(self.connection.mock_calls, calls)
        return
def create_mock_response(url, response_type, **kwargs):
    response = MagicMock()

    response.request.url = url
    response.request.method = kwargs.get("method", "GET")
    response.request.headers = {}
    response.request.body = None

    if response_type == "redirect":
        response.status_code = 301
        response.headers = {"location": kwargs["location"]}
    elif response_type == "error":
        response.status_code = kwargs.get("status_code", 500)
        response.reason = kwargs.get("reason", "fake reason")
        response.text = '{{"reason":"{}"}}'.format(kwargs.get("reason", "fake reason"))
        response.json = lambda: json.loads(response.text)
    elif response_type == "stream":
        response.status_code = kwargs.get("status_code", 200)
        response.headers = {
            "content-disposition": 'attachment; filename="fname.ext"',
            "content-type": "application/octet-stream",
            "content-length": len(response.text),
        }
        response.iter_content = lambda buffer_size: IterateContents(
            kwargs["contents"], kwargs["buffer_size"], kwargs.get("partial_start", 0), kwargs.get("partial_end", None)
        )
    else:
        response.status_code = 200
        response.text = kwargs["text"]
        response.json = lambda: json.loads(response.text)
        response.headers = {"content-type": "application/json", "content-length": len(response.text)}

    return response
Ejemplo n.º 3
0
    def test_json_parsing_error(self):
        # Make sure if the json parsing fails, we get a useful exception

        # Create a mock response that raises an exception when we try to get the json from it
        mock_response = MagicMock()
        mock_response.text = "This was the content"
        mock_response.content = mock_response.text.encode("utf-8")
        mock_response.json.side_effect = Exception("This is an exception")

        # Mock session that returns our mock response on a 'get' call.
        mock_session = MagicMock()
        mock_session.get.return_value = mock_response

        client = OnaApiClient("example.com", "2384729347234")
        with patch.object(client, "session") as mock_session_method:
            # 'session' method on our client returns our mock session
            mock_session_method.return_value = mock_session

            try:
                client.get("foo")
            except OnaApiClientException as e:
                # Make sure the exception has lots of useful info
                s = str(e)
                self.assertIn("could not be parsed", s)
                self.assertIn("This is an exception", s)
                self.assertIn("This was the content", s)
            else:
                self.fail("Expected OnaApiClientException")
Ejemplo n.º 4
0
def test_metrics(monkeypatch):
    client = client_mock(monkeypatch)

    resp = MagicMock()
    resp.text = 'metrics'

    client.return_value.session.get.return_value = resp

    parsed = MagicMock()
    parsed.samples = [
        ('metric-1', {}, 20.17), ('metric-2', {'verb': 'GET'}, 20.16), ('metric-1', {'verb': 'POST'}, 20.18)
    ]

    parser = MagicMock()
    parser.return_value = [parsed]

    monkeypatch.setattr('zmon_worker_monitor.builtins.plugins.kubernetes.text_string_to_metric_families', parser)

    k = KubernetesWrapper()
    metrics = k.metrics()

    expected = {
        'metric-1': [({}, 20.17), ({'verb': 'POST'}, 20.18)],
        'metric-2': [({'verb': 'GET'}, 20.16)],
    }

    assert metrics == expected

    parser.assert_called_with(resp.text)
    client.return_value.session.get.assert_called_with(CLUSTER_URL + '/metrics')
Ejemplo n.º 5
0
    def test_provider_shows_validation_error_message(self):
        provider = AuthorizeNetProvider(
            login_id=LOGIN_ID, transaction_key=TRANSACTION_KEY)

        error_msg = 'The merchant does not accept this type of credit card.'
        response_data = [
            ERROR_PROCESSING,
            '',
            '',
            error_msg,
            '',
            '',
            '1234']

        with patch('requests.post') as mocked_post:
            post = MagicMock()
            # post.ok = False
            post.text = '|'.join(response_data)
            mocked_post.return_value = post
            form = provider.get_form(self.payment, data=PROCESS_DATA)
            self.assertEqual(form.errors['__all__'][0], error_msg)
            self.assertFalse(form.is_valid())            
        self.assertEqual(self.payment.status, 'error')
        self.assertEqual(self.payment.captured_amount, 0)
        self.assertEqual(self.payment.message, error_msg)
Ejemplo n.º 6
0
    def test_handle_http_error(self, transport, input):
        status, error_cls = input

        error_body_json = {
            'message': 'error message',
            'support_email': '*****@*****.**'
        }
        error_body_text = json.dumps(error_body_json)

        mock_response = MagicMock()
        mock_response.status_code = status
        mock_response.text = error_body_text
        mock_response.json.return_value = error_body_json

        error = HTTPError('error message', status)
        error.response = mock_response

        with pytest.raises(error_cls) as excinfo:
            transport._handle_http_error(error)

        err = excinfo.value
        assert err.message == 'error message'
        assert err.status == status
        assert err.raw == error_body_text
        assert err.json == error_body_json
Ejemplo n.º 7
0
    def test_signups_worker_retries(self) -> None:
        """Tests the retry logic of signups queue."""
        fake_client = self.FakeClient()

        user_id = self.example_user('hamlet').id
        data = {'user_id': user_id, 'id': 'test_missed'}
        fake_client.queue.append(('signups', data))

        def fake_publish(queue_name: str, event: Dict[str, Any], processor: Callable[[Any], None]) -> None:
            fake_client.queue.append((queue_name, event))

        fake_response = MagicMock()
        fake_response.status_code = 400
        fake_response.text = ujson.dumps({'title': ''})
        with simulated_queue_client(lambda: fake_client):
            worker = queue_processors.SignupWorker()
            worker.setup()
            with patch('zerver.worker.queue_processors.requests.post',
                       return_value=fake_response), \
                    patch('zerver.lib.queue.queue_json_publish',
                          side_effect=fake_publish), \
                    patch('logging.info'), \
                    self.settings(MAILCHIMP_API_KEY='one-two',
                                  PRODUCTION=True,
                                  ZULIP_FRIENDS_LIST_ID='id'):
                worker.start()

        self.assertEqual(data['failed_tries'], 4)
Ejemplo n.º 8
0
 def test_does_not_find_labels(self, m_requests):
     mock_response = MagicMock()
     job_config = '<?xml version="1.0" encoding="UTF-8"?><project></project>'
     mock_response.text = job_config
     m_requests.get.return_value = mock_response
     result = util.match_node_from_job_config("https://jenkins.ceph.com/job/ceph-pull-requests")
     assert not result
Ejemplo n.º 9
0
def _build_mock_request(method):
    status_values = {
        'get': 200,
        'put': 200,
        'post': 201,
        'delete': 204
    }

    # Build response
    response = MagicMock()
    response.status_code = status_values[method]

    if method == 'get':
        response.headers = {
            'content-type': 'application/rdf+xml'
        }
        response.text = 'value returned'

    def _mock_request(url, headers={}, data=''):
        # Check headers
        if 'Authorization' not in headers:
            response.status_code = 401

        if method == 'get' and 'Accept' not in headers:
            response.status_code = 406

        if (method == 'put' or method == 'post') and 'Content-Type' not in headers:
            response.status_code = 415

        response.url = url
        return response

    return _mock_request
Ejemplo n.º 10
0
 def test_finds_labels(self, m_requests):
     mock_response = MagicMock()
     job_config = '<?xml version="1.0" encoding="UTF-8"?><project><assignedNode>amd64 &amp;&amp; debian</assignedNode></project>'
     mock_response.text = job_config
     m_requests.get.return_value = mock_response
     result = util.match_node_from_job_config("https://jenkins.ceph.com/job/ceph-pull-requests")
     assert result == "wheezy"
Ejemplo n.º 11
0
 def response_for(method, url, *args, **kwargs):
     method = method.upper()
     mocked_response = MagicMock(requests.Response)
     if url not in urls_to_responses:
         mocked_response.status_code = 404
         mocked_response.text = "NOT FOUND"
     elif method not in urls_to_responses[url]:
         mocked_response.status_code = 405
         mocked_response.text = "METHOD NOT ALLOWED"
     else:
         content, code = urls_to_responses[url][method]
         mocked_response.status_code = code
         if isinstance(content, dict):
             mocked_response.json.return_value = content
         else:
             mocked_response.text = content
     return mocked_response
Ejemplo n.º 12
0
 def test_does_not_find_labels(self, m_requests):
     mock_response = MagicMock()
     job_config = '<?xml version="1.0" encoding="UTF-8"?><project></project>'
     mock_response.text = job_config
     m_requests.get.return_value = mock_response
     result = util.match_node_from_job_config(
         "https://jenkins.ceph.com/job/ceph-pull-requests")
     assert not result
Ejemplo n.º 13
0
 def test_finds_labels(self, m_requests):
     mock_response = MagicMock()
     job_config = '<?xml version="1.0" encoding="UTF-8"?><project><assignedNode>amd64 &amp;&amp; debian</assignedNode></project>'
     mock_response.text = job_config
     m_requests.get.return_value = mock_response
     result = util.match_node_from_job_config(
         "https://jenkins.ceph.com/job/ceph-pull-requests")
     assert result == "wheezy"
Ejemplo n.º 14
0
 def test006_new_error_existing(self, m_Tag, m_process_error):
     tag = MagicMock()
     tag.text = "whatever"
     self.request.json = dict()
     self.request.json['text'] = tag.text
     m_Tag.query_find_all.return_value = [tag]
     api_tags.new(self.db)
     m_process_error.assert_called()
Ejemplo n.º 15
0
 def test_redirect_3ds_form(self):
     """ Test redirection to 3DS page if requested by PayU """
     self.set_up_provider(True, False)
     with patch('requests.post') as mocked_post:
         post = MagicMock()
         post.text = json.dumps({
             "redirectUri": "test_redirect_uri",
             "status": {
                 "statusCode": "WARNING_CONTINUE_3DS"
             },
             "orderId": 123
         })
         post.status_code = 200
         mocked_post.return_value = post
         with self.assertRaises(RedirectNeeded) as context:
             self.provider.get_form(payment=self.payment)
         mocked_post.assert_called_once_with(
             'http://mock.url/api/v2_1/orders/',
             allow_redirects=False,
             data=JSONEquals(
                 {
                     "merchantPosId":
                     "123abc",
                     "continueUrl":
                     "http://foo_succ.com",
                     "buyer": {
                         "lastName": "Bar",
                         "phone": None,
                         "email": "*****@*****.**",
                         "firstName": "Foo",
                         "language": "en"
                     },
                     "description":
                     "payment",
                     "notifyUrl":
                     "https://example.com/process_url/token",
                     "totalAmount":
                     22000,
                     "currencyCode":
                     "USD",
                     "extOrderId":
                     "bar_token",
                     "products": [{
                         "name": "foo",
                         "quantity": 10,
                         "subUnit": 100,
                         "currency": "USD",
                         "unitPrice": 2000,
                     }],
                     "customerIp":
                     "123"
                 }, ),
             headers={
                 'Authorization': 'Bearer test_access_token',
                 'Content-Type': 'application/json'
             },
         )
         self.assertEqual(context.exception.args[0], 'test_redirect_uri')
def create_mock_response(url, response_type, **kwargs):
    response = MagicMock()

    response.request.url = url
    response.request.method = kwargs.get('method', 'GET')
    response.request.headers = {}
    response.request.body = None

    if response_type == "redirect":
        response.status_code = 301
        response.headers = {'location': kwargs['location']}
    elif response_type == "error":
        response.status_code = kwargs.get('status_code', 500)
        response.reason = kwargs.get('reason', 'fake reason')
        response.text = '{{"reason":"{}"}}'.format(
            kwargs.get('reason', 'fake reason'))
        response.json = lambda: json.loads(response.text)
    elif response_type == "stream":
        response.status_code = kwargs.get('status_code', 200)
        response.headers = {
            'content-disposition': 'attachment; filename="fname.ext"',
            'content-type': 'application/octet-stream',
            'content-length': len(response.text)
        }

        def _create_iterator(buffer_size):
            response._content_iterator = IterateContents(
                kwargs['contents'], kwargs['buffer_size'],
                kwargs.get('partial_start', 0),
                kwargs.get('partial_end', None))
            return response._content_iterator

        response.iter_content = _create_iterator
        response.raw.tell = lambda: response._content_iterator.total_bytes_iterated(
        )
    else:
        response.status_code = 200
        response.text = kwargs['text']
        response.json = lambda: json.loads(response.text)
        response.headers = {
            'content-type': 'application/json',
            'content-length': len(response.text)
        }

    return response
Ejemplo n.º 17
0
    def test_redirect_payu_no_status_code(self):
        self.set_up_provider(True, False)
        with patch("requests.post") as mocked_post:
            post = MagicMock()
            post_text = {
                "redirectUri": "test_redirect_uri",
                "orderId": 123,
            }
            post.text = json.dumps(post_text)
            post.status_code = 200
            mocked_post.return_value = post
            with self.assertRaises(RedirectNeeded) as context:
                self.provider.get_form(payment=self.payment)
            self.assertEqual(context.exception.args[0], "http://cancel.com")

            mocked_post.assert_called_once_with(
                "http://mock.url/api/v2_1/orders/",
                allow_redirects=False,
                data=JSONEquals(
                    {
                        "buyer": {
                            "email": "*****@*****.**",
                            "language": "en",
                            "lastName": "Bar",
                            "firstName": "Foo",
                            "phone": None,
                        },
                        "description":
                        "payment",
                        "totalAmount":
                        22000,
                        "merchantPosId":
                        "123abc",
                        "customerIp":
                        "123",
                        "notifyUrl":
                        "https://example.com/process_url/token",
                        "extOrderId":
                        "bar_token",
                        "products": [{
                            "currency": "USD",
                            "name": "foo",
                            "quantity": 10,
                            "unitPrice": 2000,
                            "subUnit": 100,
                        }],
                        "continueUrl":
                        "http://foo_succ.com",
                        "currencyCode":
                        "USD",
                    }, ),
                headers={
                    "Authorization": "Bearer test_access_token",
                    "Content-Type": "application/json",
                },
            )
def create_mock_response(url, response_type, **kwargs):
    response = MagicMock()

    response.request.url = url
    response.request.method = kwargs.get('method', 'GET')
    response.request.headers = {}
    response.request.body = None

    if response_type == "redirect":
        response.status_code = 301
        response.headers = {'location': kwargs['location']}
    elif response_type == "error":
        response.status_code = kwargs.get('status_code', 500)
        response.reason = kwargs.get('reason', 'fake reason')
        response.text = '{{"reason":"{}"}}'.format(kwargs.get('reason', 'fake reason'))
        response.json = lambda: json.loads(response.text)
    elif response_type == "stream":
        response.status_code = kwargs.get('status_code', 200)
        response.headers = {
            'content-disposition': 'attachment; filename="fname.ext"',
            'content-type': 'application/octet-stream',
            'content-length': len(response.text)
        }

        def _create_iterator(buffer_size):
            response._content_iterator = IterateContents(kwargs['contents'],
                                                         kwargs['buffer_size'],
                                                         kwargs.get('partial_start', 0),
                                                         kwargs.get('partial_end', None))
            return response._content_iterator

        response.iter_content = _create_iterator
        response.raw.tell = lambda: response._content_iterator.total_bytes_iterated()
    else:
        response.status_code = 200
        response.text = kwargs['text']
        response.json = lambda: json.loads(response.text)
        response.headers = {
            'content-type': 'application/json',
            'content-length': len(response.text)
        }

    return response
Ejemplo n.º 19
0
    def get_response(self, method, url, verify, headers, data=None):
        resp = MagicMock()
        resp.status_code = 400
        parts = urlparse(url)
        url = parts[2]
        params = parts[4]

        if method == "GET":
            if url == "/infrastructures/infid" or url == "/infrastructures/newinfid":
                resp.status_code = 200
                resp.json.return_value = {"uri-list": [{ "uri": "http://server.com/infid/vms/0"},
                                                       { "uri": "http://server.com/infid/vms/1"}]}
            elif url == "/infrastructures/infid/state":
                resp.status_code = 200
                resp.json.return_value = {"state": {"state": "configured",
                                                    "vm_states": {"0": "configured",
                                                                  "1": "configured"}}}
            elif url == "/infrastructures/infid/vms/0":
                resp.status_code = 200
                resp.text = "network public (outbound='yes')\n"
                resp.text += "system front (net_interface.0.connection = 'public' and net_interface.0.ip = '8.8.8.8')"
            elif url == "/infrastructures/infid/data":
                resp.status_code = 200
                resp.json.return_value = {"data": "data"}
            elif url == "/infrastructures/infid/contmsg":
                resp.status_code = 200
                resp.text = "contmsg"
            elif url == "/infrastructures/infid/radl":
                resp.status_code = 200
                resp.text = "network public (outbound='yes')\n"
                resp.text += "system front (net_interface.0.connection = 'public' and net_interface.0.ip = '8.8.8.8')"
        elif method == "POST":
            if url == "/infrastructures":
                resp.status_code = 200
                resp.text = 'http://server.com/infid'
        elif method == "PUT":
            if url == "/infrastructures":
                resp.status_code = 200
                resp.text = 'http://server.com/newinfid'
            elif url == "/infrastructures/infid/reconfigure":
                resp.status_code = 200
                resp.text = ''
            elif url == "/infrastructures/newinfid/stop":
                resp.status_code = 200
                resp.text = ''
            elif url == "/infrastructures/infid/start":
                resp.status_code = 200
                resp.text = ''
        elif method == "DELETE":
            if url == "/infrastructures/infid":
                resp.status_code = 200

        return resp
Ejemplo n.º 20
0
 def test_call_html(self):
     ret = '<html><head></head><body></body></html>'
     read = MagicMock()
     read.headers = {'content-type': 'application/html'}
     read.text = MagicMock(return_value=ret)
     u = 'http://localhost/testing'
     with patch('requests.get') as mock_method:
         mock_method.return_value = read
         request = ApiRequest('mm', ApcUrl(u))()
         self.assertEqual(request.text(), ret)
Ejemplo n.º 21
0
    def test_fields(self, mocked_requests):
        """"""
        mocked_result = MagicMock()
        mocked_result.text = self.sample_response
        mocked_requests.get.return_value = mocked_result

        # print self.client.fields("sf1", "2010")

        self.assertTrue(isinstance(self.client.fields("sf1", "2010"), dict))
        self.assertTrue('H0040002' in self.client.fields("sf1", "2010"))
Ejemplo n.º 22
0
def test_dcos_log_v2_500(mocked_http_get):
    mock_http_response = MagicMock()
    mock_http_response.status_code = 500
    mock_http_response.text = "foo bar error"
    mocked_http_get.return_value = mock_http_response

    task = {'id': 'test-task'}
    with pytest.raises(DCOSException) as excinfo:
        _dcos_log_v2(False, [task], 10, 'stdout')
    assert 'foo bar error' in str(excinfo.value)
Ejemplo n.º 23
0
 def test_redirect_payu(self):
     self.set_up_provider(True, False)
     with patch('requests.post') as mocked_post:
         post = MagicMock()
         post.text = '{"redirectUri": "test_redirect_uri", "status": {"statusCode": "SUCCESS"}, "orderId": 123}'
         post.status_code = 200
         mocked_post.return_value = post
         with self.assertRaises(RedirectNeeded) as context:
             self.provider.get_form(payment=self.payment)
         self.assertEqual(context.exception.args[0], 'test_redirect_uri')
Ejemplo n.º 24
0
Archivo: Docker.py Proyecto: bbsyaya/im
    def get_response(self, method, url, verify, cert, headers, data):
        resp = MagicMock()
        parts = uriparse(url)
        url = parts[2]
        # params = parts[4]

        if method == "GET":
            if url == '/info':
                resp.status_code = 200
                if self.swarm:
                    resp.text = '{"Swarm": {"LocalNodeState": "active"}}'
                else:
                    resp.text = '{"Swarm": {"LocalNodeState": "inactive"}}'
            elif url == "/api/":
                resp.status_code = 200
                resp.text = '{"versions": "v1"}'
            elif url == "/containers/1/json":
                resp.status_code = 200
                resp.text = '{"State": {"Running": 1}, "NetworkSettings": {"IPAddress": "10.0.0.1"}}'
            elif url == "/services/1":
                resp.status_code = 200
                resp.text = (
                    '{"UpdateStatus": {"CompletedAt": "2016-06-07T21:10:20.269723157Z"},'
                    '"Endpoint": {"VirtualIPs": [{"Addr": "10.0.0.1/16"}]}}')
            elif url.startswith("/tasks?filters"):
                resp.status_code = 200
                resp.text = (
                    '[{"Status": {"State": "rejected", "Err": "Err"}}, {"Status": {"State": "running"}}]'
                )
        elif method == "POST":
            if url == "/containers/create":
                resp.status_code = 201
                resp.text = '{"Id": "id"}'
            elif url == "/services/create":
                resp.status_code = 201
                resp.text = '{"ID": "id"}'
            elif url == "/images/create":
                resp.status_code = 200
            elif url.endswith("/start"):
                resp.status_code = 204
            elif url.endswith("/stop"):
                resp.status_code = 204
            elif url == "/volumes/create":
                resp.status_code = 201
            elif url == "/networks/create":
                resp.status_code = 201
        elif method == "DELETE":
            if url.endswith("/containers/1"):
                resp.status_code = 204
            if url.endswith("/servicess/1"):
                resp.status_code = 200

        return resp
Ejemplo n.º 25
0
def _given_config_url_response_content_is(config):
    http_client = MagicMock(spec="requests.Session")
    config_response = MagicMock()
    config_response.text = config

    http_client_get = MagicMock()
    http_client_get.return_value = config_response
    http_client.get = http_client_get

    return http_client
Ejemplo n.º 26
0
 def test_retrieve_runner_instance_id_awsmeta(self, mock_requests_get,
                                              mock_gethostname):
     """ Test retrieve runner instance id, successfully getting data from aws """
     mock_response = MagicMock()
     mock_response.text = "awsdata"
     mock_requests_get.return_value = mock_response
     with LogCapture(level=logging.INFO) as log_output:
         self.assertEqual(terraform_config.generate_runner_hostname(),
                          "awsdata")
         log_output.check()
Ejemplo n.º 27
0
    def it_uses_lastfm_to_find_song(self, twitter, complete_song):
        complete_song.return_value = {}
        tweet = MagicMock()
        tweet.text = "Wake up by Motopony, from #SoundHound http:\/\/t.co\/n2egIeV5dC"
        tweet.created_at = "Thu May 30 00:00:20 +0000 2013"
        twitter.Api.return_value.GetUserTimeline = lambda x: [tweet]

        tracks = twit.get_user_listens('satshabad')

        expect(tracks[0]).contains('type')
        expect(tracks[0]).contains('dateListened')
Ejemplo n.º 28
0
    def test_get_observations(self, mock_get, caps_mock):
        # This is almost similar to the previous test except that it gets
        # observations matching a collection and start/end criteria
        # Also, patch the CAOM2RepoClient now.
        caps_mock.get_service_host.return_value = 'some.host.com'
        caps_mock.return_value.get_access_url.return_value =\
            'http://serviceurl/caom2repo/pub'
        response = MagicMock()
        response.status_code = 200
        last_datetime = '2000-10-10T12:30:00.333'
        response.text = \
            ('CFHT\t700000o\t2000-10-10T12:20:11.123\t'
             '3e00ca6129dc8358315015204ab9fe15\nCFHT\t700001o\t' +
             last_datetime + '\t3e00ca6129dc8358315015204ab9fe15')
        mock_get.return_value = response

        level = logging.DEBUG
        visitor = CAOM2RepoClient(auth.Subject(), level)
        end_date = util.utils.str2ivoa(last_datetime)

        expect_observations = ['700000o', '700001o']
        self.assertEqual(expect_observations,
                         visitor._get_observations('cfht'))
        self.assertEqual(end_date, visitor._start)
        mock_get.assert_called_once_with(
            ('vos://cadc.nrc.ca~vospace/CADC/std/CAOM2Repository#obs-1.2',
             'cfht'),
            params={'MAXREC': core.BATCH_SIZE})

        mock_get.reset_mock()
        visitor._get_observations('cfht',
                                  end=datetime.strptime(
                                      '2000-11-11', '%Y-%m-%d'))
        mock_get.assert_called_once_with(
            ('vos://cadc.nrc.ca~vospace/CADC/std/CAOM2Repository#obs-1.2',
             'cfht'),
            params={
                'END': '2000-11-11T00:00:00.000',
                'MAXREC': core.BATCH_SIZE
            })

        mock_get.reset_mock()
        visitor._get_observations(
            'cfht',
            start=datetime.strptime('2000-11-11', '%Y-%m-%d'),
            end=datetime.strptime('2000-11-12', '%Y-%m-%d'))
        mock_get.assert_called_once_with(
            ('vos://cadc.nrc.ca~vospace/CADC/std/CAOM2Repository#obs-1.2',
             'cfht'),
            params={
                'START': '2000-11-11T00:00:00.000',
                'END': '2000-11-12T00:00:00.000',
                'MAXREC': core.BATCH_SIZE
            })
Ejemplo n.º 29
0
    def get(endpoint, params, **kwargs):
        """Mock `request.get` method."""
        with current_app.test_request_context():
            with current_app.test_client() as client:
                if endpoint == 'http://auditor/oai2d':
                    oai_url = url_for('invenio_oaiserver.response', **params)
                    res = client.get(oai_url)

                    mock_res = MagicMock()
                    mock_res.text = res.get_data(as_text=True)
                    return mock_res
Ejemplo n.º 30
0
def test_api_request_call_html():
    return_value = "<html><head></head><body></body></html>"

    read = MagicMock()
    read.headers = {"content-type": "application/html"}
    read.text = MagicMock(return_value=return_value)

    with patch("requests.get") as mock_method:
        mock_method.return_value = read
        request = ApiRequest("mm", ApcUrl("http://localhost/testing"))()
        assert request.text() == return_value
Ejemplo n.º 31
0
    def test__tmdb__TMDBSearch__get_movies__WillReturnAnEmptyList__WhenTMDBReturnsZeroMovies(
            self, mock_requests):
        mock_response = MagicMock()
        mock_response.text = "{\"results\": [], \"page\": 1, \"total_pages\": 1}"
        mock_requests.get.return_value = mock_response
        expected_results = []

        searcher = TMDBSearcher()
        actual_results = searcher.get_movies('blade runner')

        self.assertEqual(expected_results, actual_results)
Ejemplo n.º 32
0
    def get(endpoint, params, **kwargs):
        """Mock `request.get` method."""
        with current_app.test_request_context():
            with current_app.test_client() as client:
                if endpoint == 'http://auditor/oai2d':
                    oai_url = url_for('invenio_oaiserver.response', **params)
                    res = client.get(oai_url)

                    mock_res = MagicMock()
                    mock_res.text = res.get_data(as_text=True)
                    return mock_res
Ejemplo n.º 33
0
    def test_ticket_count_unauthorized(self):
        response_mock = MagicMock()
        response_mock.status_code = 403
        response_mock.text = None

        with self.assertRaises(livezilla.APIError):
            self.connector.http_client.post = MagicMock(return_value=response_mock)
            self.connector.ticket_count()
            self.connector.http_client.post.assert_called_once_with(self.LZ_URL, data={'p_user': self.LZ_USER,
                                                                                       'p_pass': self.password_md5,
                                                                                       'p_tickets_list': 1})
Ejemplo n.º 34
0
 def test_auto_complete_recurring_cvv2(self):
     """ Test processing renew when cvv2 form is required - it should return the payment processing URL """
     self.set_up_provider(True, True)
     with patch('requests.post') as mocked_post:
         post = MagicMock()
         post.text = '{"redirectUri": "test_redirect_uri", "status": {"statusCode": "WARNING_CONTINUE_CVV"}, "orderId": 123}'
         post.status_code = 200
         mocked_post.return_value = post
         redirect = self.provider.auto_complete_recurring(self.payment)
         self.assertEqual(redirect, "https://example.com/payment/token")
     self.assertEqual(self.payment.status, PaymentStatus.WAITING)
     self.assertEqual(self.payment.captured_amount, Decimal('0'))
Ejemplo n.º 35
0
 def test_WBAPIHTTPError_exception_returns_error_page_with_non_json_error(self, wbapi_mock):
     """ WBAPIHTTPERROR non-json details are passed thru to client in error page
     """
     response_mock = MagicMock()
     response_mock.status_code = 500
     response_mock.json.side_effect = KeyError
     response_mock.text = "An Error Message"
     wbapi_mock.return_value.get_apps.side_effect = WBAPIHTTPError(response=response_mock)
     r = self.client.get('/')
     self.assertEquals(r.status_code, response_mock.status_code)
     print r.get_data()
     self.assertTrue(response_mock.text in r.get_data())
Ejemplo n.º 36
0
 def test_auto_complete_recurring(self):
     """ Test processing renew. The function should return 'success' string, if nothing is required from user. """
     self.set_up_provider(True, True)
     with patch('requests.post') as mocked_post:
         post = MagicMock()
         post.text = '{"status": {"statusCode": "SUCCESS"}, "orderId": 123}'
         post.status_code = 200
         mocked_post.return_value = post
         redirect = self.provider.auto_complete_recurring(self.payment)
         self.assertEqual(redirect, "success")
     self.assertEqual(self.payment.status, PaymentStatus.WAITING)
     self.assertEqual(self.payment.captured_amount, Decimal('0'))
Ejemplo n.º 37
0
    def test_akismet_api_ham(self, switch_is_active_mock, mock_requests):
        switch_is_active_mock.return_value = True
        response = MagicMock()
        response.text = 'false'
        mock_requests.post.return_value = response
        params = {'user_ip': '127.0.0.1', 'user_agent': 'test-agent'}
        eq_(akismet_spam_check(**params), False)

        url = 'https://akismet_api_key.rest.akismet.com/1.1/comment-check'
        data = params
        data['blog'] = 'http://example.com'
        mock_requests.post.assert_called_with(url, data=data)
Ejemplo n.º 38
0
    def test__tmdb__TMDBSearch__get_movies__WillReturnAListOfResults__WhenTMDBReturnsMultipleResults(
            self, mock_requests):

        mock_response = MagicMock()
        mock_response.text = "{\"results\": [{\"title\": \"blade runner\"}], \"page\": 1, \"total_pages\": 1}"
        mock_requests.get.return_value = mock_response
        expected_results = [{'title': 'blade runner'}]

        searcher = TMDBSearcher()
        actual_results = searcher.get_movies('blade runner')

        self.assertEqual(expected_results, actual_results)
Ejemplo n.º 39
0
Archivo: openid.py Proyecto: vigial/im
    def test_get_token_introspection(self, requests):
        mock_response = MagicMock()
        mock_response.status_code = 200
        token_info = read_file_as_string('../files/iam_token_info.json')
        mock_response.text = token_info
        requests.return_value = mock_response

        success, token_info_resp = OpenIDClient.get_token_introspection(
            self.token, "cid", "csec")

        self.assertTrue(success)
        self.assertEqual(json.loads(token_info), token_info_resp)
Ejemplo n.º 40
0
    def test_akismet_api_ham(self, switch_is_active_mock, mock_requests):
        switch_is_active_mock.return_value = True
        response = MagicMock()
        response.text = "false"
        mock_requests.post.return_value = response
        params = {"user_ip": "127.0.0.1", "user_agent": "test-agent"}
        eq_(akismet_spam_check(**params), False)

        url = "https://akismet_api_key.rest.akismet.com/1.1/comment-check"
        data = params
        data["blog"] = "http://example.com"
        mock_requests.post.assert_called_with(url, data=data)
Ejemplo n.º 41
0
Archivo: openid.py Proyecto: vigial/im
    def test_get_user_info_request(self, requests):
        mock_response = MagicMock()
        mock_response.status_code = 200
        user_info = read_file_as_string('../files/iam_user_info.json')
        mock_response.text = user_info
        requests.return_value = mock_response

        success, user_info_resp = OpenIDClient.get_user_info_request(
            self.token)

        self.assertTrue(success)
        self.assertEqual(json.loads(user_info), user_info_resp)
    def test_find_links_for_domain(self):
        mock_response = MagicMock(requests.Response())
        mock_response.text = HOME_PAGE_TEXT
        mock_response.url = URLS['HOME_PAGE_TEXT']

        actual_pages = self.link_parser.parse_response_for_links(URLS['HOME_PAGE_TEXT'], mock_response, ['a'], {})
        expected_pages = []
        expected_pages.extend(['http://test-page.com/buy', 'http://test-page.com/shopping',
                               'http://test-page.com/contact.html', 'http://test-page.com/books.html',
                               'http://test-page.com/music.html'])

        self.assertEqual(sorted(actual_pages), sorted(expected_pages))
Ejemplo n.º 43
0
def test_encoding_status(requests_get_mock, app, running_job_status_response):
    """Test if getting encoding status works."""
    job_id = "1234-2345-abcd"

    # Mock sorenson response
    sorenson_response = MagicMock()
    sorenson_response.text = running_job_status_response
    sorenson_response.status_code = 200
    requests_get_mock.return_value = sorenson_response

    encoding_status = get_encoding_status(job_id)
    assert encoding_status == ('Hold', 55.810001373291016)
Ejemplo n.º 44
0
def test_encoding_status(requests_get_mock, app, running_job_status_response):
    """Test if getting encoding status works."""
    job_id = "1234-2345-abcd"

    # Mock sorenson response
    sorenson_response = MagicMock()
    sorenson_response.text = running_job_status_response
    sorenson_response.status_code = 200
    requests_get_mock.return_value = sorenson_response

    encoding_status = get_encoding_status(job_id)
    assert encoding_status == ('Hold', 55.810001373291016)
Ejemplo n.º 45
0
 def test_gres_by_routing_engine_master_switch(self, patch_search,
                                               patch_sleep):
     try:
         BBEActions().gres_by_routing_engine_master_switch()
     except Exception as err:
         self.assertEqual(err.args[0], 'Device information not given')
     try:
         BBEActions().gres_by_routing_engine_master_switch(device='r0')
     except Exception as err:
         self.assertTrue(
             'Database Replication - Not Synchronized' in err.args[0])
     builtins.t.get_handle.return_value.is_master.return_value = False
     patch_search.return_value = None
     try:
         BBEActions().gres_by_routing_engine_master_switch(device='r0')
     except Exception as err:
         self.assertTrue(
             'Routing Engine is not ready for master switch even after maximum wait'
             in err.args[0])
     patch_search.return_value = True
     obj1 = MagicMock()
     obj1.text = 'Enabled'
     obj3 = MagicMock()
     obj3.text = 'Synchronized'
     builtins.t.get_handle.return_value.execute_rpc.return_value.response.return_value = [
         obj1, 'obj1', 'obj2', obj3
     ]
     try:
         BBEActions().gres_by_routing_engine_master_switch(device='r0')
     except Exception as err:
         self.assertEqual(err.args[0], 'GRES by master switch Failed!')
     patch_search.side_effect = [True, False]
     builtins.t.get_handle.return_value.is_master.return_value = True
     self.assertEqual(
         BBEActions().gres_by_routing_engine_master_switch(device='r0'),
         True)
     patch_search.side_effect = None
     builtins.t.get_handle.return_value.execute_rpc.return_value.response.return_value = MagicMock(
     )
Ejemplo n.º 46
0
    def test_requests_backend_fetch(self):

        # patch requests object from where it's first imported
        with patch('event.fetch.requests', spec=True) as mock_req:

            # mock the get call with "test" return value as html
            mock_resp = MagicMock()
            mock_resp.text = self.dummy_html
            mock_req.get = MagicMock(return_value=mock_resp)

            fetcher = Fetcher()
            html = fetcher.get(self.dummy_url)
            self.assertEquals(self.dummy_html, html)
Ejemplo n.º 47
0
def test_wait__success(module_patch, sleep_patch, requests_patch):
    mock_module = setup_module(module_patch)
    sleep_patch.return_value = None

    not_present_response = "Not yet\nat end TEST"
    test_response = "TEST string\nat end TEST"

    mock_resp_1 = MagicMock()
    mock_resp_1.text = not_present_response
    mock_resp_2 = MagicMock()
    mock_resp_2.text = test_response
    requests_patch.side_effect = [mock_resp_1, mock_resp_2]

    main()

    requests_patch.assert_has_calls(
        [call(TEST_PARAMS["url"]),
         call(TEST_PARAMS["url"])])
    sleep_patch.assert_called_once_with(TEST_PARAMS['test_interval_seconds'])
    mock_module.fail_json.assert_not_called()
    mock_module.exit_json.assert_called_once_with(changed=True,
                                                  response=test_response)
Ejemplo n.º 48
0
    def test_requests_backend_fetch(self):

        # patch requests object from where it's first imported
        with patch('event.fetch.requests', spec=True) as mock_req:

            # mock the get call with "test" return value as html
            mock_resp = MagicMock()
            mock_resp.text = self.dummy_html
            mock_req.get = MagicMock(return_value=mock_resp)

            fetcher = Fetcher()
            html = fetcher.get(self.dummy_url)
            self.assertEquals(self.dummy_html, html)
Ejemplo n.º 49
0
def test_http_prometheus_flat_with_filtering(monkeypatch):
    resp = MagicMock()
    resp.text = '''
# HELP http_server_requests_seconds
# TYPE http_server_requests_seconds summary
http_server_requests_seconds{exception="None",method="GET",status="200",uri="/api/hello",quantile="0.95",} 0.003080192
http_server_requests_seconds{exception="None",method="GET",status="200",uri="/api/hello",quantile="0.99",} 0.071237632
http_server_requests_seconds_count{exception="None",method="GET",status="200",uri="/api/hello",} 20.0
http_server_requests_seconds_sum{exception="None",method="GET",status="200",uri="/api/hello",} 0.103182669
# HELP http_server_requests_seconds_max
# TYPE http_server_requests_seconds_max gauge
http_server_requests_seconds_max{exception="None",method="GET",status="200",uri="/api/hello",} 0.067652582
# HELP jvm_memory_committed_bytes The amount of memory in bytes that is committed for  the Java virtual machine to use
# TYPE jvm_memory_committed_bytes gauge
jvm_memory_committed_bytes{area="nonheap",id="Code Cache",} 1.9070976E7
jvm_memory_committed_bytes{area="nonheap",id="Metaspace",} 5.5574528E7
jvm_memory_committed_bytes{area="nonheap",id="Compressed Class Space",} 7340032.0
jvm_memory_committed_bytes{area="heap",id="PS Eden Space",} 2.84688384E8
jvm_memory_committed_bytes{area="heap",id="PS Survivor Space",} 1.6252928E7
jvm_memory_committed_bytes{area="heap",id="PS Old Gen",} 2.3855104E8
# HELP httpsessions_max httpsessions_max
# TYPE httpsessions_max gauge
httpsessions_max -1.0
# HELP httpsessions_active httpsessions_active
# TYPE httpsessions_active gauge
httpsessions_active 0.0
# HELP mem mem
# TYPE mem gauge
mem 370583.0
# HELP mem_free mem_free
# TYPE mem_free gauge
mem_free 176263.0
# HELP processors processors
# TYPE processors gauge
processors 8.0

'''
    get = MagicMock()
    get.return_value = resp
    monkeypatch.setattr('requests.get', get)
    http = HttpWrapper('http://example.org/prometheus/')
    expected = {
        u'httpsessions_max': -1.0,
        u'http_server_requests_seconds_sum': {
            u'exception.None.method.GET.status.200.uri./api/hello': 0.103182669
        }
    }
    assert expected == http.prometheus_flat([
        u'httpsessions_max',
        u'http_server_requests_seconds_sum.exception.None.method.GET.status.200.uri./api/hello'
    ])
Ejemplo n.º 50
0
    def test_chat_count_empty(self):
        response = {'Chats': []}

        response_mock = MagicMock()
        response_mock.status_code = 200
        response_mock.text = json.dumps(response)

        self.connector.http_client.post = MagicMock(return_value=response_mock)
        actual = self.connector.chat_count()
        self.connector.http_client.post.assert_called_once_with(self.LZ_URL, data={'p_user': self.LZ_USER,
                                                                                   'p_pass': self.password_md5,
                                                                                   'p_chats_list': 1})
        expected = len(response['Chats'])
        self.assertEqual(expected, actual)
Ejemplo n.º 51
0
    def test_get_observations(self, mock_get, caps_mock):
        # This is almost similar to the previous test except that it gets
        # observations matching a collection and start/end criteria
        # Also, patch the CAOM2RepoClient now.
        caps_mock.get_service_host.return_value = 'some.host.com'
        caps_mock.return_value.get_access_url.return_value =\
            'http://serviceurl/caom2repo/pub'
        response = MagicMock()
        response.status_code = 200
        last_datetime = '2000-10-10T12:30:00.333'
        response.text = \
            ('CFHT\t700000o\t2000-10-10T12:20:11.123\t'
             '3e00ca6129dc8358315015204ab9fe15\nCFHT\t700001o\t' +
             last_datetime + '\t3e00ca6129dc8358315015204ab9fe15')
        mock_get.return_value = response

        level = logging.DEBUG
        visitor = CAOM2RepoClient(auth.Subject(), level)
        end_date = util.utils.str2ivoa(last_datetime)

        expect_observations = ['700000o', '700001o']
        self.assertEquals(expect_observations,
                          visitor._get_observations('cfht'))
        self.assertEquals(end_date, visitor._start)
        mock_get.assert_called_once_with((
            'vos://cadc.nrc.ca~vospace/CADC/std/CAOM2Repository#obs-1.1',
            'cfht'),
            params={'MAXREC': core.BATCH_SIZE})

        mock_get.reset_mock()
        visitor._get_observations('cfht', end=datetime.strptime('2000-11-11',
                                                                '%Y-%m-%d'))
        mock_get.assert_called_once_with((
            'vos://cadc.nrc.ca~vospace/CADC/std/CAOM2Repository#obs-1.1',
            'cfht'),
            params={'END': '2000-11-11T00:00:00.000',
                    'MAXREC': core.BATCH_SIZE})

        mock_get.reset_mock()
        visitor._get_observations('cfht',
                                  start=datetime.strptime('2000-11-11',
                                                          '%Y-%m-%d'),
                                  end=datetime.strptime('2000-11-12',
                                                        '%Y-%m-%d'))
        mock_get.assert_called_once_with((
            'vos://cadc.nrc.ca~vospace/CADC/std/CAOM2Repository#obs-1.1',
            'cfht'), params={'START': '2000-11-11T00:00:00.000',
                             'END': '2000-11-12T00:00:00.000',
                             'MAXREC': core.BATCH_SIZE})
Ejemplo n.º 52
0
    def test_phrase_search(self):
        """
        moar tests
        """

        mock_es_conn = MagicMock()
        patches = {
            'RangeFilter' : DEFAULT,
            'ESRange' : DEFAULT,
            'FilteredQuery' : DEFAULT,
            'TermsFilter' : DEFAULT,
            'MatchAllQuery' : DEFAULT,
            'ANDFilter' : DEFAULT,
            'get_es_connection' : MagicMock(return_value=mock_es_conn)
        }

        my_dict = {'bibleverse' : 'test 1:1'}
        def getitem(name):
            return my_dict[name]

        def setitem(name, val):
            my_dict[name] = val

        with patch.multiple('topic_analysis.topic_extraction', **patches) as mocks:
            mock_es_doc = MagicMock()
            mock_es_doc.text = "love and awesome peace on earth! homey!"
            mock_es_doc._meta.score = 99
            mock_es_doc.__getitem__.side_effect = getitem
            mock_result_set = [
                mock_es_doc
            ]
            mock_es_conn.search.return_value = mock_result_set
            ret = topic_extraction.phrase_search([[{'text': 'love peace', 'weight' : 1}]],
                                                 ['john 3:16'],
                                                 date(2014, 01, 01),
                                                 date(2014, 01, 07))
            # num topics
            self.assertEquals(1, len(ret))
            ret = ret[0]
            # num topic terms
            self.assertEquals(1, len(ret))

            # phrase ret
            phrase_ret = ret[0]
            expected = {'weight': 1, 'text': 'love peace', 'es_score': 99, 'final_score': 99,
                        'bibleverse':'test 1:1',
                        'es_phrase': 'love and awesome peace on earth',
                        'tweet_text': 'love and awesome peace on earth! homey!'}
            self.assertEquals(expected, phrase_ret)
Ejemplo n.º 53
0
def test_start_encoding(requests_post_mock, app, start_response):
    """Test if starting encoding works."""
    filename = 'file://cernbox-smb.cern.ch/eoscds/test/sorenson_input/' \
               '1111-dddd-3333-aaaa/data.mp4'
    # Random preset from config
    aspect_ratio, quality = '16:9', '360p'

    # Mock sorenson response
    sorenson_response = MagicMock()
    sorenson_response.text = start_response
    sorenson_response.status_code = 200
    requests_post_mock.return_value = sorenson_response

    job_id = start_encoding(filename, '', quality, aspect_ratio)
    assert job_id == "1234-2345-abcd"
Ejemplo n.º 54
0
    def test_akismet_api_ham(self, switch_is_active_mock, mock_requests):
        switch_is_active_mock.return_value = True
        response = MagicMock()
        response.text = 'false'
        mock_requests.post.return_value = response
        params = {
            'user_ip': '127.0.0.1',
            'user_agent': 'test-agent'
        }
        eq_(akismet_spam_check(**params), False)

        url = 'https://akismet_api_key.rest.akismet.com/1.1/comment-check'
        data = params
        data['blog'] = 'http://example.com'
        mock_requests.post.assert_called_with(url, data=data)
Ejemplo n.º 55
0
    def test_get(self):
        response = MagicMock()
        response.ok = True
        response.text = 'content'

        self.module.get = MagicMock(return_value=response)

        result = self.mid.get()

        self.module.get.assert_called_with('http://')
        self.assertEqual(result, response.text)

        response.ok = False

        with self.assertRaises(HTTPMiddleware.Error):
            self.mid.get()
Ejemplo n.º 56
0
def test_http_prometheus(monkeypatch):
    resp = MagicMock()
    # see http://prometheus.io/docs/instrumenting/exposition_formats/#text-format-details
    resp.text = '''
# HELP api_http_request_count The total number of HTTP requests.
# TYPE api_http_request_count counter
http_request_count{method="post",code="200"} 1027 1395066363000
http_request_count{method="post",code="400"}    3 1395066363000
'''
    get = MagicMock()
    get.return_value = resp
    monkeypatch.setattr('requests.get', get)
    http = HttpWrapper('http://example.org/prometheus/')
    expected = {u'http_request_count': [({u'code': u'200', u'method': u'post'}, 1027.0),
                                        ({u'code': u'400', u'method': u'post'}, 3.0)]}
    assert expected == http.prometheus()
Ejemplo n.º 57
0
    def test_patch(self):
        response = MagicMock()
        response.ok = True
        response.text = 'content'
        data = 'data'

        self.module.patch = MagicMock(return_value=response)

        result = self.mid.patch(data)

        self.module.patch.assert_called_with('http://', data=data)
        self.assertEqual(result, response.text)

        response.ok = False

        with self.assertRaises(HTTPMiddleware.Error):
            self.mid.patch(data)
Ejemplo n.º 58
0
    def test_guess_language_unintelligible_response(self):
        # If the gengo api returns some crazy non-json response, make sure
        # that guess_language should throw a GengoAPIFailure.
        gengo_api = gengo_utils.FjordGengo()

        with patch('fjord.translations.gengo_utils.requests') as req_patch:
            # Create a mock that we can call .post() on and it returns
            # a response that has a .json() method that throws a
            # ValueError which is what happens when it's not valid
            # JSON.
            post_return = MagicMock()
            post_return.text = 'abcd'
            post_return.status_code = 500
            post_return.json.side_effect = ValueError('bleh')
            req_patch.post.return_value = post_return

            with pytest.raises(gengo_utils.GengoAPIFailure):
                gengo_api.guess_language(u'whatever text')
Ejemplo n.º 59
0
def test_http(monkeypatch):
    resp = MagicMock()
    resp.status_code = 200
    resp.text = '"foo"'
    resp.content = resp.text
    resp.json.return_value = "foo"
    get = MagicMock()
    get.return_value = resp
    monkeypatch.setattr("requests.get", get)
    http = HttpWrapper("http://example.org")
    assert 200 == http.code()
    assert '"foo"' == http.text()
    assert "foo" == http.json()
    assert 5 == http.content_size()
    resp.json.side_effect = Exception("JSON fail")
    with pytest.raises(HttpError) as ex:
        http.json()
    assert "JSON fail" == ex.value.message