def test_init(self):
        requests = Mock()
        requests.request = Mock(return_value=self.response_login)
        with patch("cloudify_vsphere.contentlibrary.requests", requests):
            # correct session id
            cl = contentlibrary.ContentLibrary({'host': 'host',
                                                'username': '******',
                                                'password': '******',
                                                'allow_insecure': True})
            cl.__del__()

            # wrong session id
            response = Mock()
            response.json = Mock(return_value={"value": 'other_id'})
            response.cookies = {'vmware-api-session-id': 'session_id'}
            requests.request = Mock(return_value=response)
            with self.assertRaises(NonRecoverableError):
                contentlibrary.ContentLibrary({'host': 'host',
                                               'username': '******',
                                               'password': '******',
                                               'allow_insecure': True})
            # no response
            response = Mock()
            response.json = Mock(return_value={})
            response.cookies = {}
            requests.request = Mock(return_value=response)
            with self.assertRaises(NonRecoverableError):
                contentlibrary.ContentLibrary({'host': 'host',
                                               'username': '******',
                                               'password': '******',
                                               'allow_insecure': True})
Ejemplo n.º 2
0
    def test_photo_queryset(self):
        viewset_mock = Mock(spec=PhotoViewSet)

        viewset_mock.request = Mock(user=self.user2)
        self.assertEqual(len(PhotoViewSet.get_queryset(viewset_mock)), 2)

        self.contest.publish_date = date.today() - timedelta(days=1)
        self.contest.save()

        viewset_mock.request = Mock(user=self.user2)
        self.assertEqual(len(PhotoViewSet.get_queryset(viewset_mock)), 3)
Ejemplo n.º 3
0
    def test_return_correct_body_for_multiple_response(self):
        item1 = Mock(file_name="file1")
        item1.request = "request1"

        item2 = Mock(file_name="file2")
        item2.request = "request2"
        # item2.title = Mock(return_value="title2")

        mapper = CherryPyMapper()
        mapper.cherrypy = Mock()
        mapper.cherrypy.url = Mock(return_value="some url")

        body = log.log_multiple_matches([item1, item2])
        self.assertEqual(body, "Matched 2 items, choosing the first one\n- file1\nrequest1\n\n- file2\nrequest2\n")
Ejemplo n.º 4
0
  def test_concurrency_no_auth(self):
    lock = Lock()
    calls = set()
    items = []

    def add_item(method, url, **kwargs):
      thread = kwargs['thread']
      with lock:
        if items:
          other = items.pop()
          ok_(other != thread)
        else:
          items.append(thread)
      sleep(0.25)
      with lock:
        ok_(not items)
        calls.add(thread)
      return Mock()

    session = Mock()
    session.request = add_item
    client = KerberosClient('http://nn', max_concurrency=1, session=session)
    args = ('POST', 'http://foo')
    t1 = Thread(
      target=client._request,
      args=args,
      kwargs={'thread': 1, 'auth': True}
    )
    t1.start()
    t2 = Thread(target=client._request, args=args, kwargs={'thread': 2})
    t2.start()
    t1.join()
    t2.join()
    eq_(calls, set([1, 2]))
Ejemplo n.º 5
0
    def test_onionoo_too_many_answers(self):
        agent = Mock()
        resp = Mock()
        resp.code = 200

        def feed_response(protocol):
            config = {
                "relays": [
                    {
                        "fingerprint": "00786E43CCC5409753F25E36031C5CEA6EA43702",
                    },
                    {
                        "fingerprint": "boom",
                    }
                ]
            }
            protocol.dataReceived(json.dumps(config).encode())
            protocol.connectionLost(Failure(ResponseDone()))
        resp.deliverBody = Mock(side_effect=feed_response)
        agent.request = Mock(return_value=defer.succeed(resp))

        with self.assertRaises(Exception) as ctx:
            yield self.router.get_onionoo_details(agent)

        self.assertTrue(
            "multiple relays for" in str(ctx.exception)
        )
    def test_content_item_deploy_fail(self):
        # failed deployment
        response_deployment_state = Mock()
        response_deployment_state.cookies = {}
        response_deployment_state.json = Mock(return_value={"value": {
            'name': 'def',
            'id': 'id'}})

        response_failed_deployment = Mock()
        response_failed_deployment.cookies = {}
        response_failed_deployment.json = Mock(return_value={"value": {
            'name': 'def',
            'succeeded': False,
            'id': 'id'}})

        _responses = [self.response_logout,
                      response_failed_deployment,
                      response_deployment_state,
                      self.response_login]

        def _fake_response(*argc, **kwargs):
            return _responses.pop()

        requests = Mock()
        requests.request = _fake_response
        # check correct deployment
        with patch("cloudify_vsphere.contentlibrary.requests", requests):
            with self.assertRaises(NonRecoverableError):
                cl = contentlibrary.ContentLibrary({'host': 'host',
                                                    'username': '******',
                                                    'password': '******',
                                                    'allow_insecure': True})
                cl.content_item_deploy(
                    "abc", {'target': '_target'}, {'param': '_param'})
            cl.__del__()
Ejemplo n.º 7
0
def unauthorized_response():
    res = Mock(DefaultNetworkResponse, headers={})
    _set_content_and_json_from_content(res, content=b'')
    res.status_code = 401
    res.ok = False
    res.request = Mock()
    return res
    def test_content_library_get(self):
        response_list = Mock()
        response_list.cookies = {}
        response_list.json = Mock(return_value={"value": ['abc']})

        response_library = Mock()
        response_library.cookies = {}
        response_library.json = Mock(return_value={"value": {'name': 'abc',
                                                             'id': 'id'}})

        _responses = [self.response_logout,
                      response_library,
                      response_list,
                      self.response_login]

        def _fake_response(*argc, **kwargs):
            return _responses.pop()

        requests = Mock()
        requests.request = _fake_response
        # check content libraries list
        with patch("cloudify_vsphere.contentlibrary.requests", requests):
            cl = contentlibrary.ContentLibrary({'host': 'host',
                                                'username': '******',
                                                'password': '******',
                                                'allow_insecure': True})

            self.assertEqual(cl.content_library_get("abc"),
                             {'name': 'abc', 'id': 'id'})
            cl.__del__()
Ejemplo n.º 9
0
def test_execute_script_both(mock_requests):
    r = Mock()
    r.status_code = 200
    r.content = resource_string(
        __name__,
        'assets/test_execute_script_both.xml'
    )
    r.request = Mock()
    mock_requests.post.return_value = r
    name = 'test_execute_script'
    engine = 'groovy'
    script = 'htmlOut.print("a")\nrawOut.print("b")'
    raw, html = h.execute_script(name, engine, script)
    mock_requests.post.assert_called_with(
        url='https://localhost:8443/engine/job/%s/script' % name,
        data=dict(
            engine=engine,
            script=script
        ),
        auth=None,
        verify=False,
        headers={'accept': 'application/xml'},
        allow_redirects=False,
        timeout=None
    )
    assert_equals("raw", raw)
    assert_equals("html", html)
Ejemplo n.º 10
0
 def test_target_source_changed(self):
     validator = DjangoUserPermissionValidator('value')
     ctx = Mock(spec=['user'])
     ctx.request = Mock()
     ctx.request.user.has_perm.return_value = False
     self.assertFalse(validator.is_write_authorized(ctx, None, 'a', 'b'))
     ctx.request.user.has_perm.assert_called_with('value')
Ejemplo n.º 11
0
 def test_target_source_not_changed(self):
     validator = DjangoUserPermissionValidator('value')
     ctx = Mock(spec=['user'])
     ctx.request = Mock()
     # Should not call has_perm
     ctx.request.user.has_perm.side_effect = Exception
     self.assertTrue(validator.is_write_authorized(ctx, None, 'a', 'a'))
Ejemplo n.º 12
0
 def test_target_source_changed(self):
     validator = DjangoUserPermissionValidator('value')
     ctx = Mock(spec=['user'])
     ctx.request = Mock()
     ctx.request.user.has_perm.return_value = False
     self.assertFalse(validator.is_write_authorized(ctx, None, 'a', 'b'))
     ctx.request.user.has_perm.assert_called_with('value')
Ejemplo n.º 13
0
 def test_target_source_not_changed(self):
     validator = DjangoUserPermissionValidator('value')
     ctx = Mock(spec=['user'])
     ctx.request = Mock()
     # Should not call has_perm
     ctx.request.user.has_perm.side_effect = Exception
     self.assertTrue(validator.is_write_authorized(ctx, None, 'a', 'a'))
Ejemplo n.º 14
0
    def test_socks_agent_tcp_host_port(self):
        reactor = Mock()
        config = Mock()
        config.SocksPort = []
        proto = Mock()
        gold = object()
        proto.request = Mock(return_value=defer.succeed(gold))

        def getConnection(key, endpoint):
            self.assertTrue(isinstance(endpoint, TorSocksEndpoint))
            self.assertTrue(endpoint._tls)
            self.assertEqual(endpoint._host, u'meejah.ca')
            self.assertEqual(endpoint._port, 443)
            return defer.succeed(proto)

        pool = Mock()
        pool.getConnection = getConnection

        # do the test
        agent = yield agent_for_socks_port(reactor,
                                           config,
                                           '127.0.0.50:1234',
                                           pool=pool)

        # apart from the getConnection asserts...
        res = yield agent.request(b'GET', b'https://meejah.ca')
        self.assertIs(res, gold)
    def test_cleanup_parmeters(self):
        _responses = [self.response_logout,
                      self.response_login]

        def _fake_response(*argc, **kwargs):
            return _responses.pop()

        requests = Mock()
        requests.request = _fake_response
        # check correct deployment
        with patch("cloudify_vsphere.contentlibrary.requests", requests):
            cl = contentlibrary.ContentLibrary({'host': 'host',
                                                'username': '******',
                                                'password': '******',
                                                'allow_insecure': True})
            self.assertEqual(
                cl._cleanup_specs({"additional_parameters": [{
                    "type": "DeploymentOptionParams",
                    "@class": "com.vmware.vcenter.ovf.deployment_option_params"
                }]}),
                {'additional_parameters': [collections.OrderedDict([(
                    # class should be always first in list
                    '@class', 'com.vmware.vcenter.ovf.deployment_option_params'
                ), (
                    'type', 'DeploymentOptionParams'
                )])]}
            )
            cl.__del__()
Ejemplo n.º 16
0
def DatetimeDataConverter(mockTimeZone):
    """Set up a `DatetimeDataConverter` object for tests."""
    widget = Mock()
    widget.request = zope.publisher.browser.TestRequest()
    field = Mock()
    field.missing_value = None
    return icemac.addressbook.browser.form.DatetimeDataConverter(field, widget)
Ejemplo n.º 17
0
    def test_method_as_str(self):
        # noinspection PyShadowingNames
        def foo(_):
            pass

        # noinspection PyUnresolvedReferences
        with patch.object(MyClass, 'foo', foo):
            profile_function_or_method('silk.tests.test_dynamic_profiling',
                                       'MyClass.foo', 'test')
            mock_data_collector = Mock()
            mock_data_collector.queries = []
            mock_data_collector.request = Request()
            with patch('silk.profiling.profiler.DataCollector',
                       return_value=mock_data_collector) as mock_DataCollector:
                MyClass().foo()
                self.assertEqual(
                    mock_DataCollector.return_value.register_profile.
                    call_count, 1)
                call_args = mock_DataCollector.return_value.register_profile.call_args[
                    0][0]
                self.assertDictContainsSubset(
                    {
                        'func_name': foo.__name__,
                        'dynamic': True,
                        'file_path': source_file_name(),
                        'name': 'test',
                        'line_num': six.get_function_code(foo).co_firstlineno
                    }, call_args)
Ejemplo n.º 18
0
    def test_widget_addform_url_on_addform(self):
        from plone.app.widgets.dx import AjaxSelectWidget
        widget = AjaxSelectWidget(self.request)
        form = Mock()
        from zope.interface import directlyProvides
        from z3c.form.interfaces import IAddForm
        directlyProvides(form, IAddForm)
        form.request = {'URL': 'http://addform_url'}
        widget.form = form
        self.assertEqual(
            {
                'name': None,
                'value': u'',
                'pattern': 'select2',
                'pattern_options': {'separator': ';'},
            },
            widget._base_args(),
        )
        widget.vocabulary = 'vocabulary1'
        self.assertEqual(
            {
                'name': None,
                'value': u'',
                'pattern': 'select2',
                'pattern_options': {
                    'separator': ';',
                    'vocabularyUrl':
                    'http://addform_url/@@getVocabulary?name=vocabulary1'}

            },
            widget._base_args(),
        )
    def test_should_not_update_state_if_unaavailable(self):
        # Set
        app = NewrelicApp('1111','777')
        headers = {"X-Api-Key":'1111'}
        url     ='/v2/applications/777.json'

        # Mocks
        connection_obj         = Mock()
        response_obj           = Mock()
        httplib.HTTPConnection = Mock(return_value=connection_obj)

        response_obj.status        = 500 # Error
        response_obj.read          = Mock(return_value='')
        connection_obj.connect     = Mock()
        connection_obj.request     = Mock()
        connection_obj.getresponse = Mock(return_value=response_obj)

        # Assertion
        app.update_state()

        connection_obj.connect.assert_called_once()
        connection_obj.request.assert_called_once_with('GET', url, '', headers)
        connection_obj.getresponse.assert_called_once()

        self.assertFalse(app.reachable)
Ejemplo n.º 20
0
    def test_handle_produce_response_on_nonretriable(self, fake_decode,
                                                     fake_retry):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
        response = Mock()
        response.code = 500
        response.error = False
        response.request = Mock()
        response.request._batch = [m1, m2]
        response.request._id = 1
        body = {
            'offsets': [{}, {}],
            'value_schema_id': 1,
            'key_schema_id': 2,
            'error_code': 50101,
            'message': 'Nonretriable'
        }
        fake_decode.return_value = body

        self.producer._handle_produce_response('test_driver', response)

        calls = [
            call('test_driver', m1, 'nonretriable'),
            call('test_driver', m2, 'nonretriable')
        ]
        self.client.mock_for('drop_message').assert_has_calls(calls)
Ejemplo n.º 21
0
 def setUp(self):
     proto = Mock()
     self.pool = Mock()
     self.expected_response = object()
     proto.request = Mock(
         return_value=defer.succeed(self.expected_response))
     self.pool.getConnection = Mock(return_value=defer.succeed(proto))
Ejemplo n.º 22
0
    def test_onionoo_success(self):
        agent = Mock()
        resp = Mock()
        resp.code = 200

        def feed_response(protocol):
            config = {
                "relays": [
                    {
                        "fingerprint":
                        "00786E43CCC5409753F25E36031C5CEA6EA43702",
                    },
                ]
            }
            protocol.dataReceived(json.dumps(config).encode())
            protocol.connectionLost(Failure(ResponseDone()))

        resp.deliverBody = Mock(side_effect=feed_response)
        agent.request = Mock(return_value=defer.succeed(resp))

        data = yield self.router.get_onionoo_details(agent)

        self.assertTrue('fingerprint' in data)
        self.assertTrue(
            data['fingerprint'] == "00786E43CCC5409753F25E36031C5CEA6EA43702")
Ejemplo n.º 23
0
    def test_handle_produce_success_mixed_success(self, fake_retry):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
        m3 = Message('test_driver', {'val': 3}, None, None, 0, 1)
        offsets = [{},
                   {'error_code': 1, 'message': 'Nonretriable'},
                   {'error_code': 2, 'message': 'Retriable'}]
        response = Mock()
        response.request = Mock()
        response.request._batch = [m1, m2, m3]
        response.request._id = 1
        body = {'offsets': offsets,
                'value_schema_id': 1,
                'key_schema_id': 2}

        self.producer._handle_produce_success('test_driver', response, body)

        self.client.mock_for('produce_success').assert_called_once_with('test_driver',
                                                                        [(m1, {})],
                                                                        [(m2, offsets[1]),
                                                                         (m3, offsets[2])])
        self.client.mock_for('drop_message').assert_called_once_with('test_driver',
                                                                     m2,
                                                                     'nonretriable')
        fake_retry.assert_called_once_with('test_driver', m3)
Ejemplo n.º 24
0
    def test_return_correct_body_for_multiple_response(self):
        item1 = Mock(file_name="file1")
        item1.request = "request1"

        item2 = Mock(file_name="file2")
        item2.request = "request2"
        # item2.title = Mock(return_value="title2")

        mapper = CherryPyMapper()
        mapper.cherrypy = Mock()
        mapper.cherrypy.url = Mock(return_value="some url")

        body = log.log_multiple_matches([item1, item2])
        self.assertEqual(
            body,
            "Matched 2 items, choosing the first one\n- file1\nrequest1\n\n- file2\nrequest2\n"
        )
Ejemplo n.º 25
0
def mock_data_collector():
    mock = Mock()
    mock.queries = []
    mock.local = Mock()
    r = RequestSkill()
    mock.local.request = r
    mock.request = r
    return mock
 def _dummy_send(*args, **kwargs):
     dummy_response = Mock()
     dummy_response.headers = {}
     dummy_response.status_code = status_code
     dummy_response.text = response_body
     dummy_response.request = args[0]
     _dummy_send.call_args = (args, kwargs)
     return dummy_response
Ejemplo n.º 27
0
def pytest_funcarg__response(request):
    req = request.getfuncargvalue("request")
    response = Mock()
    response.request = req
    response.request.cookie['session_key'] = "a" * 64
    response.request.session = {'session_key': "a" * 64}
    response.cookie = SimpleCookie()
    return response
Ejemplo n.º 28
0
def mock_data_collector():
    mock = Mock()
    mock.queries = []
    mock.local = Mock()
    r = Request()
    mock.local.request = r
    mock.request = r
    return mock
Ejemplo n.º 29
0
 def test_no_credentials_no_401(self):
     http = Mock()
     http.request = Mock(return_value='response')
     client = Client(http, None)
     response = client.request('/uri')
     self.assertEquals('response', response)
     http.request.assert_called_once_with(DEFAULT_INSTANCE_URL + '/uri',
                                          'GET', None, None, 5, None)
Ejemplo n.º 30
0
 def _dummy_send(*args, **kwargs):
     dummy_response = Mock()
     dummy_response.headers = {}
     dummy_response.status_code = status_code
     dummy_response.text = response_body
     dummy_response.request = args[0]
     dummy_response.cookies = {}
     _dummy_send.call_args = (args, kwargs)
     return dummy_response
Ejemplo n.º 31
0
    def test_onionoo_get_fails(self):
        agent = Mock()
        resp = Mock()
        resp.code = 500
        agent.request = Mock(return_value=defer.succeed(resp))

        with self.assertRaises(Exception) as ctx:
            yield self.router.get_onionoo_details(agent)
        self.assertTrue("Failed to lookup" in str(ctx.exception))
Ejemplo n.º 32
0
 def test_different_instance_url(self):
     credentials = Mock()
     credentials.token_response = {'instance_url': 'abcd'}
     http = Mock()
     http.request = Mock(return_value='response')
     client = Client(http, credentials)
     response = client.request('/uri')
     self.assertEquals('response', response)
     http.request.assert_called_once_with('abcd/uri', ANY, ANY, ANY, ANY,
                                          ANY)
Ejemplo n.º 33
0
    def test_return_correct_body_for_multiple_response(self):
        item1 = Mock(file_name="file1")
        item1.request = "request1"

        item2 = Mock(file_name="file2")
        item2.request = "request2"

        # Config = Mock(verbose=True)

        mapper = CherryPyMapper()
        mapper.cherrypy = Mock()
        mapper.cherrypy.url = Mock(return_value="some url")

        body = Log.multiple_matches([item1, item2])

        self.assertEqual(
            body,
            "- file1\nrequest1\n- file2\nrequest2\n",
        )
 def _dummy_send(*args, **kwargs):
     dummy_response = Mock()
     dummy_response.headers = {}
     dummy_response.getheaders = Mock(return_value={})
     dummy_response.status = status_code
     dummy_response.read = Mock(return_value=response_body)
     dummy_response.request = args[0]
     dummy_response.cookies = {}
     _dummy_send.call_args = (args, kwargs)
     return dummy_response
Ejemplo n.º 35
0
    def test_default_http_client_called(self):
        hc = Mock(stripe.http_client.HTTPClient)
        hc._verify_ssl_certs = True
        hc.name = 'mockclient'
        hc.request = Mock(return_value=("{}", 200, {}))

        stripe.default_http_client = hc
        stripe.Charge.list(limit=3)

        hc.request.assert_called_with(
            'get', 'https://api.stripe.com/v1/charges?limit=3', ANY, None)
Ejemplo n.º 36
0
    def _backend(self, session_kwargs=None):
        strategy = Mock()
        strategy.request = None
        strategy.session_get.return_value = object()
        strategy.partial_from_session.return_value = \
            (0, 'mock-backend', [], session_kwargs or {})

        backend = Mock()
        backend.name = 'mock-backend'
        backend.strategy = strategy
        return backend
Ejemplo n.º 37
0
    def test_handle_produce_success_simple_success(self):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        response = Mock()
        response.request = Mock()
        response.request._batch = [m1]
        body = {'offsets': [{}], 'value_schema_id': 1, 'key_schema_id': 2}

        self.producer._handle_produce_success('test_driver', response, body)

        self.client.mock_for('produce_success').assert_called_once_with(
            'test_driver', [(m1, {})], [])
Ejemplo n.º 38
0
    def _strategy(self, session_kwargs=None):
        backend = Mock()
        backend.name = 'mock-backend'

        strategy = Mock()
        strategy.request = None
        strategy.backend = backend
        strategy.session_get.return_value = object()
        strategy.partial_from_session.return_value = \
            (0, backend.name, [], session_kwargs or {})
        return strategy
Ejemplo n.º 39
0
    def test_onionoo_get_fails(self):
        agent = Mock()
        resp = Mock()
        resp.code = 500
        agent.request = Mock(return_value=defer.succeed(resp))

        with self.assertRaises(Exception) as ctx:
            yield self.router.get_onionoo_details(agent)
        self.assertTrue(
            "Failed to lookup" in str(ctx.exception)
        )
Ejemplo n.º 40
0
    def test_default_http_client_called(self):
        hc = Mock(stripe.http_client.HTTPClient)
        hc._verify_ssl_certs = True
        hc.name = 'mockclient'
        hc.request = Mock(return_value=("{}", 200, {}))

        stripe.default_http_client = hc
        stripe.Charge.list(limit=3)

        hc.request.assert_called_with(
            'get', 'https://api.stripe.com/v1/charges?limit=3', ANY, None)
Ejemplo n.º 41
0
    def _strategy(self, session_kwargs=None):
        backend = Mock()
        backend.name = 'mock-backend'

        strategy = Mock()
        strategy.request = None
        strategy.backend = backend
        strategy.session_get.return_value = object()
        strategy.partial_from_session.return_value = \
            (0, backend.name, [], session_kwargs or {})
        return strategy
Ejemplo n.º 42
0
    def _backend(self, session_kwargs=None):
        strategy = Mock()
        strategy.request = None
        strategy.session_get.return_value = object()
        strategy.partial_from_session.return_value = \
            (0, 'mock-backend', [], session_kwargs or {})

        backend = Mock()
        backend.name = 'mock-backend'
        backend.strategy = strategy
        return backend
Ejemplo n.º 43
0
 def test_get_event_kwargs(self, mock_fd):
     view = Mock(index=Mock(_silent=False), _silent=False)
     view.request = Mock(action='index')
     kwargs = events._get_event_kwargs(view)
     mock_fd.from_dict.assert_called_once_with(
         view._json_params, view.Model)
     assert kwargs == {
         'fields': mock_fd.from_dict(),
         'instance': view.context,
         'model': view.Model,
         'view': view
     }
Ejemplo n.º 44
0
 def test_add(self):
     with patch('httplib.HTTPConnection') as mock_http:
         mock_conn = Mock()
         mock_conn.request = Mock()
         mock_http.return_value = mock_conn
         taskqueue.add(url='http://example.com/foo',
                       params={'key': 'thekey'},
                       queue_name='test')
         mock_http.assert_called_with('example.com')
         mock_conn.request.assert_called_with(
             'POST', 'http://example.com/foo', 'key=thekey',
             {'Content-Type': 'text/plain'})
Ejemplo n.º 45
0
    def test_handle_produce_success_simple_success(self):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        response = Mock()
        response.request = Mock()
        response.request._batch = [m1]
        body = {'offsets': [{}], 'value_schema_id': 1, 'key_schema_id': 2}

        self.producer._handle_produce_success('test_driver', response, body)

        self.client.mock_for('produce_success').assert_called_once_with('test_driver',
                                                                        [(m1, {})],
                                                                        [])
Ejemplo n.º 46
0
 def test_get_event_kwargs(self, mock_fd):
     view = Mock(index=Mock(_silent=False), _silent=False)
     view.request = Mock(action='index')
     kwargs = events._get_event_kwargs(view)
     mock_fd.from_dict.assert_called_once_with(view._json_params,
                                               view.Model)
     assert kwargs == {
         'fields': mock_fd.from_dict(),
         'instance': view.context,
         'model': view.Model,
         'view': view
     }
 def test_add(self):
     with patch('httplib.HTTPConnection') as mock_http:
         mock_conn = Mock()
         mock_conn.request = Mock()
         mock_http.return_value = mock_conn
         taskqueue.add(url='http://example.com/foo',
                       params={'key': 'thekey'},
                       queue_name='test')
         mock_http.assert_called_with('example.com')
         mock_conn.request.assert_called_with(
             'POST', 'http://example.com/foo', 'key=thekey',
             {'Content-Type': 'text/plain'})
Ejemplo n.º 48
0
    def test_unknown_http_return_code(self):
        client = HttpClient()
        client.verboseLevel = 0
        client.session = Mock()
        client.session.cookies = []
        resp = Mock(spec_set=requests.Response())
        resp.request = Mock()
        resp.request.headers = {}
        resp.status_code = 999
        client.session.request = Mock(return_value=resp)

        self.assertRaises(NetworkError, client.get, 'http://foo.bar',
                          retry=False)
Ejemplo n.º 49
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.º 50
0
	def test_request_passes_the_url_without_path_and_without_query_string(self):
		http = Mock()
		http.request = Mock()
		authParamProvider = Mock()
		authParamProvider.get = Mock()
		requester = Requester(http, authParamProvider)

		requester.request(hostname="some.hostname.com",
						  method="GET",
						  apiId="API_ID",
						  apiKey="API_KEY")

		url = http.request.call_args[0][1]
		self.assertEquals("https://some.hostname.com/api/v3/", url)
    def testGetSetsCookie(self):

        httpRequestMock = Mock(return_value=(httplib2.Response({'set-cookie': 'acookie'}), ''))

        httpObjectMock = Mock()
        httpObjectMock.request = httpRequestMock

        mock = Mock(return_value=httpObjectMock)
        HttpClient._getHttpObject = mock

        client = HttpClient('username', 'password')
        client.get('http://localhost:9999/url')

        self.assertEqual('acookie', client.cookie)
    def testUnknownHttpReturnCode(self):

        httpRequestMock = Mock(return_value=(httplib2.Response({'status': '999'}), ''))

        httpObjectMock = Mock()
        httpObjectMock.request = httpRequestMock

        mock = Mock(return_value=httpObjectMock)
        HttpClient._getHttpObject = mock

        client = HttpClient('username', 'password')
        client.cookie = 'acookie'

        self.assertRaises(NetworkError, client.get, 'url')
    def test_init(self):
        requests = Mock()
        requests.request = Mock(return_value=self.response_login)
        with patch("cloudify_vsphere.contentlibrary.requests", requests):
            # correct session id
            cl = contentlibrary.ContentLibrary({
                'host': 'host',
                'username': '******',
                'password': '******',
                'allow_insecure': True
            })
            cl.__del__()

            # wrong session id
            response = Mock()
            response.json = Mock(return_value={"value": 'other_id'})
            response.cookies = {'vmware-api-session-id': 'session_id'}
            requests.request = Mock(return_value=response)
            with self.assertRaises(NonRecoverableError):
                contentlibrary.ContentLibrary({
                    'host': 'host',
                    'username': '******',
                    'password': '******',
                    'allow_insecure': True
                })
            # no response
            response = Mock()
            response.json = Mock(return_value={})
            response.cookies = {}
            requests.request = Mock(return_value=response)
            with self.assertRaises(NonRecoverableError):
                contentlibrary.ContentLibrary({
                    'host': 'host',
                    'username': '******',
                    'password': '******',
                    'allow_insecure': True
                })
Ejemplo n.º 54
0
def test_submit_configuration(mock_requests):
    r = Mock()
    r.status_code = 200
    r.request = Mock()
    r.content = resource_string(
        __name__,
        'assets/test_get_job_info.xml'
    )
    mock_requests.get.return_value = r
    r = Mock()
    r.status_code = 200
    r.request = Mock()
    mock_requests.put.return_value = r
    name = 'test_submit_configuration'
    h.submit_configuration(name, 'cxml')
    mock_requests.put.assert_called_with(
        url=('https://localhost:8443/engine/job/'
             'test/jobdir/crawler-beans.cxml'),
        data='cxml',
        auth=None,
        verify=False,
        headers={'accept': 'application/xml'},
        timeout=None
    )
Ejemplo n.º 55
0
    def test_request_passes_the_url_without_path_and_without_query_string(
            self):
        http = Mock()
        http.request = Mock()
        authParamProvider = Mock()
        authParamProvider.get = Mock()
        requester = Requester(http, authParamProvider)

        requester.request(hostname="some.hostname.com",
                          method="GET",
                          apiId="API_ID",
                          apiKey="API_KEY")

        url = http.request.call_args[0][1]
        self.assertEqual("https://some.hostname.com/api/v3/", url)
Ejemplo n.º 56
0
def test_default_network_response_properties_pass_through_to_session_response_properties(access_token):
    mock_session_response = Mock(Response)
    mock_session_response.status_code = 200
    mock_session_response.headers = {}
    mock_session_response.raw = Mock()
    mock_session_response.content = json.dumps('content')
    mock_session_response.request = Mock()
    network_reponse = DefaultNetworkResponse(mock_session_response, access_token)
    assert network_reponse.json() == mock_session_response.json()
    assert network_reponse.content == mock_session_response.content
    assert network_reponse.ok == mock_session_response.ok
    assert network_reponse.status_code == mock_session_response.status_code
    assert network_reponse.headers == mock_session_response.headers
    assert network_reponse.response_as_stream == mock_session_response.raw
    assert network_reponse.access_token_used == access_token
Ejemplo n.º 57
0
    def test_unknown_http_return_code(self):
        client = HttpClient()
        client.verboseLevel = 0
        client.session = Mock()
        client.session.cookies = []
        resp = Mock(spec_set=requests.Response())
        resp.request = Mock()
        resp.request.headers = {}
        resp.status_code = 999
        client.session.request = Mock(return_value=resp)

        self.assertRaises(NetworkError,
                          client.get,
                          'http://foo.bar',
                          retry=False)