def test_update_peers_view(self): logic = self.logic gui = self.app logic.customizer = MainWindowCustomizer(gui.main_window, logic) logic.customizer.new_task_dialog_customizer = Mock() peer = Mock() peer.address = "10.10.10.10" peer.port = 1031 peer.key_id = "KEYID" peer.node_name = "NODE 1" peer2 = Mock() peer2.address = "10.10.10.20" peer2.port = 1034 peer2.key_id = "KEYID2" peer2.node_name = "NODE 2" logic._update_peers_view( [DictSerializer.dump(peer), DictSerializer.dump(peer2)]) table = logic.customizer.gui.ui.connectedPeersTable self.assertEqual(table.rowCount(), 2) self.assertEqual(table.item(0, 0).text(), "10.10.10.10") self.assertEqual(table.item(1, 0).text(), "10.10.10.20") self.assertEqual(table.item(0, 1).text(), "1031") self.assertEqual(table.item(1, 1).text(), "1034") self.assertEqual(table.item(0, 2).text(), "KEYID") self.assertEqual(table.item(1, 2).text(), "KEYID2") self.assertEqual(table.item(0, 3).text(), "NODE 1") self.assertEqual(table.item(1, 3).text(), "NODE 2")
def test_peers(self): peer1 = Mock() peer1.name = "server1" peer1.ip = "192.168.0.13" peer1.port = "88" peer2 = Mock() peer2.name = "server2" peer2.ip = "192.168.0.22" peer2.port = "88" cluster = Mock() cluster.name = "a_cluster" cluster.nodes = [ Mock(peer=peer1), Mock(peer=None), # skipped Mock(peer=peer2), Mock(peer=peer1), # duplicate, skipped ] stanza = PeersStanza(cluster) self.assertEqual(stanza.header, "peers a_cluster") self.assertEqual( set(stanza.lines), set([ "peer server1 192.168.0.13:88", "peer server2 192.168.0.22:88" ]) )
def test_delete(self): # arrange uuid = 'uuid' network_name = 'network_name' network = Mock() network.name = network_name si = Mock() vm = Mock() vm.network = [network] connection_detail = Mock() connection_detail.host = Mock() connection_detail.username = Mock() connection_detail.password = Mock() connection_detail.port = Mock() pv_service = Mock() pv_service.connect = Mock(return_value=si) pv_service.find_by_uuid = Mock(return_value=vm) connector = VirtualSwitchToMachineDisconnectCommand( pv_service, Mock(), 'anetwork') # act res = connector.disconnect(si, uuid, network_name) # assert self.assertTrue( pv_service.connect.called_with(connection_detail.host, connection_detail.username, connection_detail.password, connection_detail.port)) self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid)) self.assertTrue(res)
def test_delete_all(self): # arrange uuid = 'uuid' si = Mock() vm = Mock() connection_detail = Mock() connection_detail.host = Mock() connection_detail.username = Mock() connection_detail.password = Mock() connection_detail.port = Mock() pv_service = Mock() pv_service.connect = Mock(return_value=si) pv_service.find_by_uuid = Mock(return_value=vm) connector = VirtualSwitchToMachineDisconnectCommand( pv_service, Mock(), 'anetwork') # virtual_switch_to_machine_connector.remove_interfaces_from_vm = Mock(return_value=True) connector.get_network_by_name = lambda x, y: Mock() # act res = connector.disconnect(si, uuid) # assert self.assertTrue( pv_service.connect.called_with(connection_detail.host, connection_detail.username, connection_detail.password, connection_detail.port)) self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid)) # self.assertTrue(virtual_switch_to_machine_connector.remove_interfaces_from_vm.called_with(vm)) self.assertTrue(res)
def test_delete_all(self): # arrange uuid = 'uuid' si = Mock() vm = Mock() connection_detail = Mock() connection_detail.host = Mock() connection_detail.username = Mock() connection_detail.password = Mock() connection_detail.port = Mock() pv_service = Mock() pv_service.connect = Mock(return_value=si) pv_service.find_by_uuid = Mock(return_value=vm) connector = VirtualSwitchToMachineDisconnectCommand(pv_service, Mock(), 'anetwork') # virtual_switch_to_machine_connector.remove_interfaces_from_vm = Mock(return_value=True) connector.get_network_by_name = lambda x, y: Mock() # act res = connector.disconnect(si, uuid) # assert self.assertTrue(pv_service.connect.called_with(connection_detail.host, connection_detail.username, connection_detail.password, connection_detail.port)) self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid)) # self.assertTrue(virtual_switch_to_machine_connector.remove_interfaces_from_vm.called_with(vm)) self.assertTrue(res)
def test_delete(self): # arrange uuid = 'uuid' network_name = 'network_name' network = Mock() network.name = network_name si = Mock() vm = Mock() vm.network = [network] connection_detail = Mock() connection_detail.host = Mock() connection_detail.username = Mock() connection_detail.password = Mock() connection_detail.port = Mock() pv_service = Mock() pv_service.connect = Mock(return_value=si) pv_service.find_by_uuid = Mock(return_value=vm) connector = VirtualSwitchToMachineDisconnectCommand(pv_service, Mock(), 'anetwork') # act res = connector.disconnect(si, uuid, network_name) # assert self.assertTrue(pv_service.connect.called_with(connection_detail.host, connection_detail.username, connection_detail.password, connection_detail.port)) self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid)) self.assertTrue(res)
def test_attach_stream_failure(self): @implementer(ICircuitContainer) class FakeContainer(object): pass container = FakeContainer() stream = Stream(container) stream.source_addr = ipaddress.IPv4Address(u'0.0.0.0') stream.source_port = 12345 circuit = Mock() circuit.when_built = Mock(return_value=Failure(Exception('testing1234'))) target_endpoint = Mock() src_addr = Mock() src_addr.host = u'0.0.0.0' src_addr.port = 12345 target_endpoint._get_address = Mock(return_value=defer.succeed(src_addr)) reactor = Mock() state = Mock() TorCircuitEndpoint( reactor, state, circuit, target_endpoint, ) attacher = yield _get_circuit_attacher(reactor, state) d = attacher.add_endpoint(target_endpoint, circuit) self.assertEquals(len(attacher._circuit_targets), 1) # this will fail, but should be ignored yield attacher.attach_stream(stream, []) with self.assertRaises(Exception) as ctx: yield d self.assertTrue("testing1234" in str(ctx.exception))
def test_generate_directives_from_xml_sitemap(self): from smoketest.directives import ( CheckDirective, FileParser, ) sitemap_file = self._create_file('.xml') sitemap_file.write( '<?xml version="1.0" encoding="utf-8"?>' + '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' + '<url><loc>https://www.example.com</loc></url></urlset>') sitemap_file.close() options = Mock() options.cachebust = False options.level = 'live' options.port = None options.scheme = None file_parser = FileParser(sitemap_file.name, options) directives = list(file_parser.generate_directives()) directive = directives[0] self.assertEqual(len(directives), 1) self.assertTrue(isinstance(directive, CheckDirective)) self.assertEqual(directive.follow_redirects, False) self.assertEqual(directive.urls, ['https://www.example.com'])
def test_get_response(self): from smoketest.directives import CheckDirective from smoketest.settings import get_ca_path elem = { 'url': 'http://www.usnews.com', } options = Mock() options.scheme = None options.port = '8999' options.level = 'sand14' options.cachebust = False options.dry_run = False directive = CheckDirective(elem, options) directive.session = Mock() url = 'http://www.usnews.com' extra_headers = {'a': 'b'} response = directive.get_response(url, extra_headers) directive.session.get.assert_called_once_with( url, verify=get_ca_path(), allow_redirects=False, timeout=directive.timeout, headers=extra_headers ) self.assertEqual(response, directive.session.get.return_value)
def test_circuit_stream_failure(self): """ If the stream-attach fails the error propagates """ reactor = Mock() torstate = Mock() target = Mock() target.connect = Mock(return_value=defer.succeed(None)) circ = Mock() circ.state = 'FAILED' src_addr = Mock() src_addr.host = 'host' src_addr.port = 1234 target._get_address = Mock(return_value=defer.succeed(src_addr)) stream = Mock() stream.source_port = 1234 stream.source_addr = 'host' # okay, so we fire up our circuit-endpoint with mostly mocked # things, and a circuit that's already in 'FAILED' state. ep = TorCircuitEndpoint(reactor, torstate, circ, target) # should get a Failure from the connect() d = ep.connect(Mock()) attacher = yield _get_circuit_attacher(reactor, Mock()) attacher.attach_stream_failure(stream, RuntimeError("a bad thing")) try: yield d self.fail("Should get exception") except RuntimeError as e: self.assertEqual("a bad thing", str(e))
def test_success(self): """ Connect a stream via a circuit """ reactor = Mock() torstate = Mock() target = Mock() target.connect = Mock(return_value=defer.succeed('fake proto')) circ = Mock() circ.state = 'NEW' src_addr = Mock() src_addr.host = 'host' src_addr.port = 1234 target._get_address = Mock(return_value=defer.succeed(src_addr)) stream = Mock() stream.source_port = 1234 stream.source_addr = 'host' # okay, so we fire up our circuit-endpoint with mostly mocked # things, and a circuit that's already in 'FAILED' state. ep = TorCircuitEndpoint(reactor, torstate, circ, target) # should get a Failure from the connect() d = ep.connect(Mock()) attacher = yield _get_circuit_attacher(reactor, torstate) yield attacher.attach_stream(stream, [circ]) proto = yield d self.assertEqual(proto, 'fake proto')
def test_provider_override(self): alt_provider = Mock(spec=boto.provider.Provider) alt_provider.host = None alt_provider.host_header = None alt_provider.port = None alt_provider.secret_key = 'alt_secret_key' layer1 = Layer1(aws_access_key_id='aws_access_key', aws_secret_access_key='aws_secret_key', provider=alt_provider) self.assertEqual(alt_provider, layer1.provider)
def test_init_provider_override(self): alt_provider = Mock(spec=boto.provider.Provider) alt_provider.host = None alt_provider.host_header = None alt_provider.port = None alt_provider.secret_key = 'alt_secret_key' dynamodb = DynamoDBConnection(provider=alt_provider) self.assertEqual(dynamodb.provider, alt_provider)
def _get_mock_segment(self, name, datadir, port, hostname, address): m = Mock() m.name = name m.datadir = datadir m.port = port m.hostname = hostname m.address = address return m
def test_send_waiting_results(self): ccd = self._get_config_desc() ts = TaskServer(Node(), ccd, Mock(), self.client, use_docker_machine_manager=False) self.ts = ts ts.network = Mock() ts._mark_connected = Mock() ts.task_computer = Mock() ts.task_manager = Mock() ts.task_manager.check_timeouts.return_value = [] ts.task_keeper = Mock() ts.task_connections_helper = Mock() ts._add_pending_request = Mock() subtask_id = 'xxyyzz' wtr = Mock() ts.results_to_send[subtask_id] = wtr wtr.already_sending = True wtr.last_sending_trial = 0 wtr.delay_time = 0 wtr.subtask_id = subtask_id wtr.address = '127.0.0.1' wtr.port = 10000 ts.sync_network() self.assertFalse(ts._add_pending_request.called) wtr.last_sending_trial = 0 ts.retry_sending_task_result(subtask_id) ts.sync_network() self.assertTrue(ts._add_pending_request.called) ts._add_pending_request.called = False ts.task_sessions[subtask_id] = Mock() ts.sync_network() self.assertFalse(ts._add_pending_request.called) ts._add_pending_request.called = False ts.results_to_send = dict() wtf = wtr ts.failures_to_send[subtask_id] = wtf ts.sync_network() self.assertFalse(ts._add_pending_request.called) self.assertEqual(ts.failures_to_send, {}) ts._add_pending_request.called = False ts.task_sessions.pop(subtask_id) ts.failures_to_send[subtask_id] = wtf ts.sync_network() self.assertTrue(ts._add_pending_request.called) self.assertEqual(ts.failures_to_send, {})
def test_release_connection(self): conn = Mock() conn.host = 'foo' conn.port = 9 mypool = pool.ShardPool(self.servers) mypool._in_use_connections['foo:9'].add(conn) self.assertTrue(mypool._in_use_connections['foo:9']) mypool.release(conn) self.assertFalse(mypool._in_use_connections['foo:9'])
def create_fake_endpoint(name='source', **kw): ep = Mock() ep.zone.name = name ep.secret_key = kw.get('secret', 'secret') ep.access_key = kw.get('access', 'access') ep.port = kw.get('port', 7777) ep.host = kw.get('host', 'localhost') ep.debug = kw.get('debug', True) return ep
def _get_conn(reader): global _conn_port conn = Mock() conn.host = "localhost" conn.port = _conn_port _conn_port += 1 reader._initialize_conn(conn) reader._conn_subscribe(conn) return conn
def create_fake_endpoint(name="source", **kw): ep = Mock() ep.zone.name = name ep.secret_key = kw.get("secret", "secret") ep.access_key = kw.get("access", "access") ep.port = kw.get("port", 7777) ep.host = kw.get("host", "localhost") ep.debug = kw.get("debug", True) return ep
def test_get_db_params_returns_args_parameters(self, mock_parse_config_file): mock_parse_config_file.return_value = (None, None, None, None ) mock_args = Mock() mock_args.host = 'pumpkin' mock_args.port = 12345 mock_args.index = 'ciccio' elasticsearch_url, elasticsearch_index, elasticsearch_replicas = get_db_params(mock_args) self.assertEquals(elasticsearch_url, 'http://pumpkin:12345') self.assertEquals(elasticsearch_index, 'ciccio')
def test_by_address_with_srv(self): with patch("dns.resolver.query") as query: answer = Mock() answer.target = "different.example.org." answer.port = 12345 query.return_value = [answer] self.server = MinecraftServer.lookup("example.org") query.assert_called_once_with("_minecraft._tcp.example.org", "SRV") self.assertEqual(self.server.host, "different.example.org") self.assertEqual(self.server.port, 12345)
def test_by_address_with_srv(self): with patch("dns.resolver.resolve") as resolve: answer = Mock() answer.target = "different.example.org." answer.port = 12345 resolve.return_value = [answer] self.server = MinecraftServer.lookup("example.org") resolve.assert_called_once_with("_minecraft._tcp.example.org", "SRV") assert self.server.host == "different.example.org" assert self.server.port == 12345
def dns_query(name, _): if '-server' not in name or '-ssl' in name: return [] if name == '_etcd-server._tcp.blabla': return [] elif name == '_etcd-server._tcp.exception': raise DNSException() srv = Mock() srv.port = 2380 srv.target.to_text.return_value = 'localhost' if name == '_etcd-server._tcp.foobar' else '127.0.0.1' return [srv]
def _get_registered_scheduler_driver_master(self): driver = Mock() framework_id = Mock() framework_id.value = 'framework_id' master_info = Mock() master_info.hostname = 'localhost' master_info.port = 1234 my_scheduler = scheduler.scale_scheduler.ScaleScheduler() my_scheduler.registered(driver, framework_id, master_info) return my_scheduler, driver, master_info
def _get_registered_scheduler_driver_master(self): driver = Mock() framework_id = Mock() framework_id.value = 'framework_id' master_info = Mock() master_info.hostname = 'localhost' master_info.port = 1234 my_scheduler = scheduler.scale_scheduler.ScaleScheduler(None) my_scheduler.registered(driver,framework_id,master_info) return my_scheduler, driver, master_info
def test_chpasswd_ldap_sorting(self, mock_connection, mock_query): mock_connection.return_value = Mock() l = [] for i in range(10): mock = Mock() mock.priority = i / 2 mock.target.to_text.return_value = "srv%i.%i" % (i / 2, i) mock.port = 69 l.append(mock) mock_query.return_value = l res = get_ad_server("example.com") self.assertIn(res, ["srv4.8:69", "srv4.9:69"])
def vmware_vm_2(host_1): vmware_vm = Mock(spec=vim.VirtualMachine) vmware_vm.configure_mock(name='VM2') vmware_vm.summary.runtime.host = host_1 vmware_vm.config.instanceUuid = 'vmware-vm-uuid-2' backing = Mock(spec=vim.vm.device.VirtualEthernetCard. DistributedVirtualPortBackingInfo) backing.port = Mock(portgroupKey='dvportgroup-2', portKey='20') vmware_vm.config.hardware.device = [ Mock(backing=backing, macAddress='mac-address-2') ] return vmware_vm
def test_provider_override(self): alt_provider = Mock(spec=boto.provider.Provider) alt_provider.host = None alt_provider.host_header = None alt_provider.port = None alt_provider.secret_key = 'alt_secret_key' regions = boto.swf.regions() layer2 = boto.swf.layer2.SWFBase(domain=MOCK_DOMAIN, aws_access_key_id=MOCK_ACCESS_KEY, aws_secret_access_key=MOCK_SECRET_KEY, region=regions[0], provider=alt_provider) self.assertEqual(alt_provider, layer2._swf.provider)
def test_get_urls_from_flat_url(self): from smoketest.directives import get_urls_from_element options = Mock() options.scheme = None options.port = '8999' options.level = 'stag' options.cachebust = False elem = { 'url': 'http://www.usnews.com', } results = get_urls_from_element(elem, options) self.assertEqual(results[0], 'http://www-stag.usnews.com:8999') self.assertEqual(len(results), 1)
def test_provider_override(self): alt_provider = Mock(spec=boto.provider.Provider) alt_provider.host = None alt_provider.host_header = None alt_provider.port = None alt_provider.secret_key = 'alt_secret_key' regions=boto.swf.regions() layer2 = boto.swf.layer2.SWFBase( domain=MOCK_DOMAIN, aws_access_key_id=MOCK_ACCESS_KEY, aws_secret_access_key=MOCK_SECRET_KEY, region=regions[0], provider = alt_provider ) self.assertEqual(alt_provider, layer2._swf.provider)
def test_is_device_match_network_port_type(self): # arrange backing = Mock(spec=[]) device = Mock() port = Mock() device.backing = backing backing.port = port port.portgroupKey = 'port key' # act res = VNicService.device_is_attached_to_network(device, port.portgroupKey) # assert self.assertTrue(res)
def test_urls_from_dict_of_urls_use_other(self): from smoketest.directives import get_urls_from_element options = Mock() options.scheme = None options.port = '8999' options.level = 'sand14' options.cachebust = False elem = { 'url': { 'stag': 'http://www.usnews.com', 'other': 'http://www.google.com', } } results = get_urls_from_element(elem, options) self.assertEqual(results[0], 'http://www-sand14.google.com:8999') self.assertEqual(len(results), 1)
def test_is_device_match_network_port_type(self): # arrange backing = Mock(spec=[]) device = Mock() port = Mock() device.backing = backing backing.port = port port.portgroupKey = 'port key' # act res = VNicService.device_is_attached_to_network( device, port.portgroupKey) # assert self.assertTrue(res)
def test_urls_from_dict_of_urls_use_non_other(self): from smoketest.directives import get_urls_from_element options = Mock() options.port = '8999' options.level = 'stag' options.cachebust = True elem = { 'url': { 'stag': 'usnews.com', 'other': 'google.com', } } results = get_urls_from_element(elem, options) # Notice that it should not be cachebusted. self.assertEqual(results[0], 'usnews.com') self.assertEqual(len(results), 1)
def test_conn_for_task_failure_established(self): ccd = self._get_config_desc() ts = TaskServer(Node(), ccd, Mock(), self.client, use_docker_machine_manager=False) self.ts = ts ts.network = Mock() session = Mock() session.address = '127.0.0.1' session.port = 40102 method = ts._TaskServer__connection_for_task_failure_established method(session, 'conn_id', 'key_id', 'subtask_id', 'err_msg') self.assertEqual(session.key_id, 'key_id') self.assertIn('subtask_id', ts.task_sessions) self.assertTrue(session.send_hello.called) session.send_task_failure.assert_called_once_with('subtask_id', 'err_msg')
def test_connection_for_task_request_established(self): ccd = self._get_config_desc() ccd.min_price = 11 n = Node() ka = EllipticalKeysAuth(self.path) ts = TaskServer(n, ccd, ka, self.client, use_docker_machine_manager=False) self.ts = ts session = Mock() session.address = "10.10.10.10" session.port = 1020 ts.conn_established_for_type[TASK_CONN_TYPES['task_request']](session, "abc", "nodename", "key", "xyz", 1010, 30, 3, 1, 2) self.assertEqual(session.task_id, "xyz") self.assertEqual(session.key_id, "key") self.assertEqual(session.conn_id, "abc") self.assertEqual(ts.task_sessions["xyz"], session) session.send_hello.assert_called_with() session.request_task.assert_called_with("nodename", "xyz", 1010, 30, 3, 1, 2)
def test_redirect_test(self): from smoketest.tests import ( get_redirect_tests, RedirectTest, ) elem = { "redirect": { "status": "30X", "location": "usnews.com", }, } options = Mock() options.port = None options.level = None options.cachebust = True tests = get_redirect_tests(elem, options) self.assertIsInstance(tests[0], RedirectTest) self.assertEqual(tests[0].target_code, "30X") self.assertEqual(tests[0].target_location, "usnews.com")
def _test_attacher_both_apis(self): """ similar to above, but first set_attacher is implicit via Circuit.stream_via """ reactor = Mock() directlyProvides(reactor, IReactorCore) @implementer(IStreamAttacher) class MyAttacher(object): pass circ = Circuit(self.state) circ.state = 'BUILT' # use the "preferred" API, which will set an attacher factory = Mock() proto = Mock() proto.when_done = Mock(return_value=defer.succeed(None)) factory.connect = Mock(return_value=defer.succeed(proto)) ep = circ.stream_via(reactor, 'meejah.ca', 443, factory) addr = Mock() addr.host = '10.0.0.1' addr.port = 1011 ep._target_endpoint._get_address = Mock( return_value=defer.succeed(addr)) print("EP", ep) attacher = yield _get_circuit_attacher(reactor, self.state) print("attacher", attacher) d = ep.connect('foo') print("doin' it") stream = Mock() import ipaddress stream.source_addr = ipaddress.IPv4Address(u'10.0.0.1') stream.source_port = 1011 attacher.attach_stream(stream, []) yield d # ...now use the low-level API (should be an error) with self.assertRaises(RuntimeError) as ctx: self.state.set_attacher(MyAttacher(), FakeReactor(self)) self.assertTrue("already have an attacher" in str(ctx.exception))
def test_get_urls_from_element_with_url_list(self): from smoketest.directives import get_urls_from_element options = Mock() options.scheme = None options.port = '' options.level = 'live' options.cachebust = False elem = { "urls": [ "http://www.usnews.com", "http://www.indeed.com", ], "status": "404", } expected = [ "http://www.usnews.com", "http://www.indeed.com", ] actual = get_urls_from_element(elem, options) self.assertEqual(expected, actual)
def add_broker(self, host, port, responses=[], connect_error=None): conn = Mock() conn.host = host conn.port = port conn.closing = False if connect_error: conn.connect.return_value = self.future_error(connect_error) else: conn.connect.return_value = self.future_value(None) @gen.coroutine def get_next_response(req): log.debug("sent to %s:%s: %s", host, port, req) self.sent[(host, port)].append(req) raise gen.Return(responses.pop(0)) conn.send.side_effect = get_next_response self.broker_hosts[(host, port)] = conn
def test_available_ports(): """ Test ``available_ports`` filters out ports that are in use by ``MOCK_SERVERS``. """ ports = available_ports() assert_equals(ports, PRETEND_PORT_RANGE) mock_port = list(PRETEND_PORT_RANGE)[2] assert_true(mock_port in ports) # Now add a mock server pretend_server = Mock() pretend_server.port = mock_port PRETENDERS[1] = pretend_server # Now they should not be equal ports = available_ports() assert_not_equals(ports, PRETEND_PORT_RANGE) assert_false(mock_port in ports)
def test_port_property(self): mock = Mock(spec=network.Connection) mock.port = sentinel.port lineprotocol = network.LineProtocol(mock) self.assertEqual(sentinel.port, lineprotocol.port)