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 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 _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 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.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 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 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)
