def test_refresh_peers(self):
sa = SocketAddress('127.0.0.1', 11111)
node = MagicMock()
node.key = EllipticalKeysAuth(self.path, "TESTPRIV", "TESTPUB").get_key_id()
node.key_id = node.key
node.address = sa
node2 = MagicMock()
node2.key = EllipticalKeysAuth(self.path, "TESTPRIV2", "TESTPUB2").get_key_id()
node2.key_id = node2.key
node2.address = sa
self.service.add_peer(node.key, node)
self.service.add_peer(node2.key, node2)
self.service.peers[node.key].last_message_time = time.time() + 1000
self.service.peers[node2.key].last_message_time = time.time() + 1000
self.service.config_desc.opt_peer_num = 1000
assert len(self.service.peers) == 2
self.service.sync_network()
assert len(self.service.peers) == 2
self.service.last_refresh_peers = 0
self.service.last_peers_request = 0
self.service._peer_dbg_time_threshold = 0
self.service.sync_network()
# disabled
assert len(self.service.peers) == 2
def test_shipping_step_save_with_address_other_than_billing(rf):
address_data = {
'first_name': 'Billing Company LTD',
'last_name': 'Test',
'street_address_1': 'Test',
'street_address_2': 'Test',
'city': 'Test',
'phone': '12345678',
'postal_code': '987654',
'country': 'PL',
'country_area': '',
'company_name': 'Test'
}
data = dict(address_data,
method='dummy_shipping',
shipping_same_as_billing=False)
request = rf.post('/checkout/', data)
request.user = AnonymousUser()
request.session = {}
group = MagicMock()
group.address = None
storage = {
'address': {
'first_name': 'Billing Address',
'last_name': 'Test',
'id': 10
}
}
billing_address = Address(**address_data)
step = ShippingStep(request, storage, group, billing_address)
assert step.forms_are_valid()
step.save()
assert storage['address'] == address_data
def test_get_host_ip_hostname_resolvable(self, _query):
data = MagicMock()
data.address = '10.5.0.1'
_query.return_value = [data]
self.assertEquals(neutron_contexts.get_host_ip('myhost.example.com'),
'10.5.0.1')
_query.assert_called_with('myhost.example.com', 'A')
def test_get_host_ip_hostname_resolvable(self, _query):
data = MagicMock()
data.address = '10.5.0.1'
_query.return_value = [data]
self.assertEquals(neutron_contexts.get_host_ip('myhost.example.com'),
'10.5.0.1')
_query.assert_called_with('myhost.example.com', 'A')
def test_forwarded_session_requests(self):
ccd = self._get_config_desc()
ts = TaskServer(Node(), ccd, EllipticalKeysAuth(self.path), self.client,
use_docker_machine_manager=False)
self.ts = ts
ts.network = Mock()
key_id = str(uuid.uuid4())
conn_id = str(uuid.uuid4())
subtask_id = str(uuid.uuid4())
ts.add_forwarded_session_request(key_id, conn_id)
self.assertEqual(len(ts.forwarded_session_requests), 1)
ts.forwarded_session_requests[key_id]['time'] = 0
ts._sync_forwarded_session_requests()
self.assertEqual(len(ts.forwarded_session_requests), 0)
ts.add_forwarded_session_request(key_id, conn_id)
ts.forwarded_session_requests[key_id] = None
ts._sync_forwarded_session_requests()
self.assertEqual(len(ts.forwarded_session_requests), 0)
session = MagicMock()
session.address = '127.0.0.1'
session.port = 65535
ts.conn_established_for_type[TASK_CONN_TYPES['task_failure']](
session, conn_id, key_id, subtask_id, "None"
)
self.assertEqual(ts.task_sessions[subtask_id], session)
def _create_customer(self):
customer = MagicMock()
customer.id = 1
customer.first_name = "Ellen"
customer.last_name = "Johnson"
customer.company = "Souveniropolis"
customer.address = "14 Main Street"
customer.city = "Pecan Springs"
customer.state = "TX"
# customer.zip_code = "44628"
customer.country = "USA"
customer.email = "*****@*****.**"
# TODO: putting this here for now. we will test silver and
# strategize a little about the overall process. Thinking in the
# interest of best practices, whatever frontend app we have can
# collect this once, run it through the authorize.net backend to
# create a customer profile + payment profile, we'll store those
# and not need to store card numbers at all.
customer.meta = {
"cardNumber": "4111111111111111",
"expirationDate": "2020-12",
"cardCode": "123",
}
transaction = MagicMock()
transaction.amount = 25.00
transaction.currency = "USD"
transaction.credit_card_details = customer.credit_card_details
transaction.customer = customer
self.transaction = transaction
self.customer = customer
def test_shipping_step_save_with_address_other_than_billing(rf):
address_data = {
'first_name': 'Billing Company LTD',
'last_name': 'Test',
'street_address_1': 'Test',
'street_address_2': 'Test',
'city': 'Test',
'phone': '12345678',
'postal_code': '987654',
'country': 'PL',
'country_area': '',
'company_name': 'Test'}
data = dict(
address_data,
method='dummy_shipping',
shipping_same_as_billing=False)
request = rf.post('/checkout/', data)
request.user = AnonymousUser()
request.session = {}
group = MagicMock()
group.address = None
storage = {
'address': {
'first_name': 'Billing Address',
'last_name': 'Test',
'id': 10}}
billing_address = Address(**address_data)
step = ShippingStep(request, storage, group, billing_address)
assert step.forms_are_valid()
step.save()
assert storage['address'] == address_data
def helper_generate_service_info(self):
info = MagicMock()
info.address = self.addr
info.port = self.port
info.name = self.name
info.hostname = self.hostname
info.type = self.type
info.txt = self.txt
return info
def helper_build_info(self):
info = MagicMock()
info.address = socket.inet_aton(self.address)
info.port = self.port
info.type = self.type
info.name = self.name
info.server = self.server
info.properties = {}
return info
def test_address_save_with_address_in_group(self, mock_save):
self.request.POST = NEW_ADDRESS
self.request.POST['method'] = 0
group = MagicMock()
group.address = Address()
group.get_delivery_methods.return_value = [DummyShipping(group)]
step = ShippingStep(self.checkout, self.request, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
def test_address_save_with_address_in_group(self, mock_save):
self.request.POST = NEW_ADDRESS.copy()
self.request.POST["method"] = "dummy_shipping"
group = MagicMock()
group.address = Address()
storage = {}
step = ShippingStep(self.request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
def test_address_save_with_address_in_group(self, mock_save):
self.request.POST = NEW_ADDRESS_POST
self.request.POST['method'] = 0
group = MagicMock()
group.address = Address()
group.get_delivery_methods.return_value = [DummyShipping(group)]
step = ShippingStep(self.checkout, self.request, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
def test_address_save_with_address_in_group(self, mock_save):
self.request.POST = NEW_ADDRESS.copy()
self.request.POST['method'] = 'dummy_shipping'
group = MagicMock()
group.address = Address()
storage = {}
step = ShippingStep(self.request, storage, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
def test_address_save_without_address(self, mock_save):
self.request.POST = NEW_ADDRESS.copy()
self.request.POST["method"] = "dummy_shipping"
self.request.session = {STORAGE_SESSION_KEY: {}}
group = MagicMock()
group.address = None
storage = {}
step = ShippingStep(self.request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertEqual(type(storage["address"]), Address, "Address instance expected")
def test_address_save_with_address_in_group(self, mock_save):
request = MagicMock()
request.user.is_authenticated.return_value = False
request.session = {}
request.POST = dict(NEW_ADDRESS, method='dummy_shipping')
group = MagicMock()
group.address = NEW_ADDRESS
storage = {'address': NEW_ADDRESS}
step = ShippingStep(request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
def test_shipping_step_save_without_address(rf):
data = dict(NEW_ADDRESS, method='dummy_shipping')
request = rf.post('/checkout/', data)
request.user = AnonymousUser()
request.session = {STORAGE_SESSION_KEY: {}}
group = MagicMock()
group.address = None
storage = {'address': NEW_ADDRESS.copy()}
step = ShippingStep(request, storage, group)
assert step.forms_are_valid()
step.save()
assert isinstance(storage['address'], dict)
def test_shipping_step_save_with_address_in_group(rf):
data = dict(NEW_ADDRESS, method='dummy_shipping')
request = rf.post('/checkout/', data)
request.user = AnonymousUser()
request.session = {}
group = MagicMock()
group.address = NEW_ADDRESS.copy()
storage = {'address': NEW_ADDRESS.copy()}
step = ShippingStep(request, storage, group)
assert step.forms_are_valid()
step.save()
assert storage['address'] == NEW_ADDRESS
def test_address_save_with_address_in_group(self, mock_save):
request = MagicMock()
request.user.is_authenticated.return_value = False
request.session = {}
request.POST = dict(NEW_ADDRESS, method='dummy_shipping')
group = MagicMock()
group.address = NEW_ADDRESS
storage = {'address': NEW_ADDRESS}
step = ShippingStep(request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
def test_shipping_step_save_with_address_in_group(rf):
data = dict(NEW_ADDRESS, method='dummy_shipping')
request = rf.post('/checkout/', data)
request.user = AnonymousUser()
request.session = {}
group = MagicMock()
group.address = NEW_ADDRESS.copy()
storage = {'address': NEW_ADDRESS.copy()}
step = ShippingStep(request, storage, group)
assert step.forms_are_valid()
step.save()
assert storage['address'] == NEW_ADDRESS
def test_shipping_step_save_without_address(rf):
data = dict(NEW_ADDRESS, method='dummy_shipping')
request = rf.post('/checkout/', data)
request.user = AnonymousUser()
request.session = {STORAGE_SESSION_KEY: {}}
group = MagicMock()
group.address = None
storage = {'address': NEW_ADDRESS.copy()}
step = ShippingStep(request, storage, group)
assert step.forms_are_valid()
step.save()
assert isinstance(storage['address'], dict)
def test_address_save_without_address(self, mock_save):
self.request.POST = NEW_ADDRESS.copy()
self.request.POST['method'] = 'dummy_shipping'
self.request.session = {STORAGE_SESSION_KEY: {}}
group = MagicMock()
group.address = None
storage = {}
step = ShippingStep(self.request, storage, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertEqual(type(storage['address']), Address,
'Address instance expected')
def test_address_save_without_address(self, mock_save):
request = MagicMock()
request.user.is_authenticated.return_value = False
request.session = {}
request.POST = dict(NEW_ADDRESS, method='dummy_shipping')
request.session = {STORAGE_SESSION_KEY: {}}
group = MagicMock()
group.address = None
storage = {'address': NEW_ADDRESS}
step = ShippingStep(request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertTrue(isinstance(storage['address'], dict), 'dict expected')
def test_address_save_without_address(self, mock_save):
self.request.POST = NEW_ADDRESS_POST
self.request.POST['method'] = 0
group = MagicMock()
group.address = None
checkout = Checkout(self.request)
group.get_delivery_methods.return_value = [DummyShipping(group)]
step = ShippingStep(checkout, self.request, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
grup_storage = checkout.get_group(str(step))
self.assertEqual(type(grup_storage['address']), Address,
'Address instance expected')
def test_address_save_with_address_in_checkout(self, mock_save):
request = MagicMock()
request.user.is_authenticated.return_value = False
request.session = {}
request.POST = dict(NEW_ADDRESS, method='dummy_shipping')
original_billing_address = {'name': 'Change Me', 'id': 10}
group = MagicMock()
group.address = None
storage = {'address': original_billing_address}
step = ShippingStep(request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertEqual(storage['address'], NEW_ADDRESS)
def test_address_save_with_address_in_checkout(self, mock_save):
self.request.POST = NEW_ADDRESS.copy()
self.request.POST["method"] = "dummy_shipping"
original_billing_address_data = {"first_name": "Change", "last_name": "Me", "id": 10}
original_billing_address = Address(**original_billing_address_data)
group = MagicMock()
group.address = None
storage = {"address": original_billing_address}
step = ShippingStep(self.request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertEqual(storage["address"], Address(**NEW_ADDRESS))
self.assertEqual(storage["address"].id, None)
def test_address_save_without_address(self, mock_save):
self.request.POST = NEW_ADDRESS
self.request.POST['method'] = 0
group = MagicMock()
group.address = None
checkout = Checkout(self.request)
group.get_delivery_methods.return_value = [DummyShipping(group)]
step = ShippingStep(checkout, self.request, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
grup_storage = checkout.get_group(str(step))
self.assertEqual(type(grup_storage['address']), Address,
'Address instance expected')
def test_address_save_with_address_in_checkout(self, mock_save):
request = MagicMock()
request.user.is_authenticated.return_value = False
request.session = {}
request.POST = dict(NEW_ADDRESS, method='dummy_shipping')
original_billing_address = {'name': 'Change Me', 'id': 10}
group = MagicMock()
group.address = None
storage = {'address': original_billing_address}
step = ShippingStep(request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertEqual(storage['address'], NEW_ADDRESS)
def MockTracer(self):
"""
Construct a mock tracer.
"""
tracer = MagicMock()
tracer.address = self.tracer_host, self.tracer_port
tracer.pause_signal = signal.SIGUSR2
tracer.retry_attepts = 1
tracer.local = 0, 0
tracer.uuid = 'mock'
tracer.watchlist = {}
tracer.curframe = sys._getframe()
tracer.stack = [(sys._getframe(), 1)] * 3
tracer.skip_fn = lambda _: False
return tracer
def MockTracer(self):
"""
Construct a mock tracer.
"""
tracer = MagicMock()
tracer.address = self.tracer_host, self.tracer_port
tracer.pause_signal = signal.SIGUSR2
tracer.retry_attepts = 1
tracer.local = 0, 0
tracer.uuid = 'mock'
tracer.watchlist = {}
tracer.curframe = sys._getframe()
tracer.stack = [(sys._getframe(), 1)] * 3
tracer.skip_fn = lambda _: False
return tracer
def test_address_save_without_address(self, mock_save):
request = MagicMock()
request.user.is_authenticated.return_value = False
request.session = {}
request.POST = dict(NEW_ADDRESS, method='dummy_shipping')
request.session = {STORAGE_SESSION_KEY: {}}
group = MagicMock()
group.address = None
storage = {'address': NEW_ADDRESS}
step = ShippingStep(request, storage, group)
self.assertTrue(step.forms_are_valid(), "Forms don't validate.")
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertTrue(isinstance(storage['address'], dict),
'dict expected')
def test_shipping_step_save_with_address_in_checkout(rf):
data = dict(NEW_ADDRESS, method='dummy_shipping')
request = rf.post('/checkout/', data)
request.user = AnonymousUser()
request.session = {}
group = MagicMock()
group.address = None
storage = {
'address': {
'first_name': 'Change',
'last_name': 'Me',
'id': 10}}
step = ShippingStep(request, storage, group)
assert step.forms_are_valid()
step.save()
assert storage['address'] == NEW_ADDRESS
def test_shipping_step_save_with_address_in_checkout(rf):
data = dict(NEW_ADDRESS, method='dummy_shipping')
request = rf.post('/checkout/', data)
request.user = AnonymousUser()
request.session = {}
group = MagicMock()
group.address = None
storage = {
'address': {
'first_name': 'Change',
'last_name': 'Me',
'id': 10
}
}
step = ShippingStep(request, storage, group)
assert step.forms_are_valid()
step.save()
assert storage['address'] == NEW_ADDRESS
def test_address_save_with_address_in_checkout(self, mock_save):
self.request.POST = NEW_ADDRESS_POST
self.request.POST['method'] = 0
original_billing_address_data = {'first_name': 'Change',
'last_name': 'Me',
'id': 10}
original_billing_address = Address(**original_billing_address_data)
self.checkout.billing_address = original_billing_address
group = MagicMock()
group.address = None
group.get_delivery_methods.return_value = [DummyShipping(group)]
step = ShippingStep(self.checkout, self.request, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertEqual(self.checkout.billing_address,
Address(**original_billing_address_data))
self.assertEqual(step.group['address'].id, None)
def test_address_save_with_address_in_checkout(self, mock_save):
self.request.POST = NEW_ADDRESS.copy()
self.request.POST['method'] = 'dummy_shipping'
original_billing_address_data = {
'first_name': 'Change',
'last_name': 'Me',
'id': 10
}
original_billing_address = Address(**original_billing_address_data)
group = MagicMock()
group.address = None
storage = {'address': original_billing_address}
step = ShippingStep(self.request, storage, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertEqual(storage['address'], Address(**NEW_ADDRESS))
self.assertEqual(storage['address'].id, None)
def test_address_save_with_address_in_checkout(self, mock_save):
self.request.POST = NEW_ADDRESS
self.request.POST['method'] = 0
original_billing_address_data = {
'first_name': 'Change',
'last_name': 'Me',
'id': 10
}
original_billing_address = Address(**original_billing_address_data)
self.checkout.billing_address = original_billing_address
group = MagicMock()
group.address = None
group.get_delivery_methods.return_value = [DummyShipping(group)]
step = ShippingStep(self.checkout, self.request, group)
self.assertTrue(step.forms_are_valid(), 'Forms don\'t validate.')
step.save()
self.assertEqual(mock_save.call_count, 0)
self.assertEqual(self.checkout.billing_address,
Address(**original_billing_address_data))
self.assertEqual(step.group['address'].id, None)
def test_get_host_ip_hostname_resolvable(self, _query):
data = MagicMock()
data.address = "10.5.0.1"
_query.return_value = [data]
self.assertEquals(quantum_contexts.get_host_ip("myhost.example.com"), "10.5.0.1")
_query.assert_called_with("myhost.example.com", "A")
