def __init__(
self,
methodName,
fbsimctl_path,
use_custom_set,
):
super(FBSimctlTestCase, self).__init__(methodName)
set_path = tempfile.mkdtemp() if use_custom_set else None
self.methodName = methodName
self.use_custom_set = use_custom_set
self.fbsimctl = FBSimctl(fbsimctl_path, set_path)
def __init__(
self,
methodName: str,
fbsimctl_path: str,
use_custom_set: bool,
) -> None:
super(FBSimctlTestCase, self).__init__(methodName)
set_path = tempfile.mkdtemp() if use_custom_set else None
self.methodName = methodName
self.use_custom_set = use_custom_set
self.fbsimctl = FBSimctl(fbsimctl_path, set_path)
self.metal = Metal()
self.tmpdir = tempfile.mkdtemp()
class FBSimctlTestCase(unittest.TestCase):
def __init__(
self,
methodName,
fbsimctl_path,
use_custom_set,
):
super(FBSimctlTestCase, self).__init__(methodName)
set_path = tempfile.mkdtemp() if use_custom_set else None
self.methodName = methodName
self.use_custom_set = use_custom_set
self.fbsimctl = FBSimctl(fbsimctl_path, set_path)
def tearDown(self):
action = 'delete' if self.use_custom_set else 'shutdown'
self.fbsimctl(['--simulators', action])
def __str__(self):
return '{}: {}'.format(
self.methodName,
'Custom Set' if self.use_custom_set else 'Default Set',
)
def assertEventSuccesful(self, arguments, event_name):
return self.assertEventsFromRun(
arguments=arguments,
event_name=event_name,
event_type='ended',
min_count=1,
max_count=1,
)[0]
def assertEventsFromRun(
self,
arguments,
event_name,
event_type,
min_count=1,
max_count=None,
timeout=Defaults.TIMEOUT,
):
events = self.fbsimctl.run(arguments, timeout)
matching_events = events.matching(event_name, event_type)
match_count = len(matching_events)
if min_count is not None:
self.assertGreaterEqual(
match_count,
min_count,
'Expected at least {} {} {} event, but there were {}. Other events: \b {}'.format(
str(min_count),
event_name,
event_type,
str(match_count),
events
)
)
if max_count is not None:
self.assertLessEqual(
match_count,
max_count,
'Expected no more than {} {} {} event, but there were {}. Other events: \b {}'.format(
str(max_count),
event_name,
event_type,
str(match_count),
events
)
)
return matching_events
def assertListContainsOnly(self, expected_udids, query=[]):
events = self.fbsimctl.run(query + ['list'])
list_events = events.matching('list', 'discrete')
list_udids = [
event.get('subject').get('udid') for event in list_events
]
remainder = set(expected_udids) - set(list_udids)
self.assertEqual(
len(remainder),
0,
'Expected list command to contain {}, but it was missing'.format(
remainder
)
)
additional = set(list_udids) - set(expected_udids)
self.assertEqual(
len(additional),
0,
'Expected list command only contain {}, but it had additional {}'.format(
expected_udids,
additional,
)
)
return list_events
def assertExtractSimulator(self, json_event):
sim_json = json_event.get('subject')
self.assertIsNotNone(
sim_json,
'Expected {} to contain a simulator, but it did not'.format(
json_event,
)
)
return Simulator(sim_json)
def assertExtractAndKeyDiagnostics(self, json_events):
return {
event['subject']['short_name']: event['subject']
for event
in json_events
}
def assertCreatesSimulator(self, args):
args = ['create'] + args
return self.assertExtractSimulator(
self.assertEventSuccesful(args, 'create')
)
def testList(self):
self.fbsimctl(['list'])
def testCommandThatDoesNotExist(self):
with self.assertRaises(Exception):
self.fbsimctl(['foo'])
class FBSimctlTestCase(unittest.TestCase):
def __init__(self, methodName, fbsimctl_path, use_custom_set):
super(FBSimctlTestCase, self).__init__(methodName)
set_path = tempfile.mkdtemp() if use_custom_set else None
self.methodName = methodName
self.use_custom_set = use_custom_set
self.fbsimctl = FBSimctl(fbsimctl_path, set_path)
def tearDown(self):
action = "delete" if self.use_custom_set else "shutdown"
self.fbsimctl(["--simulators", action])
def __str__(self):
return "{}: {}".format(self.methodName, "Custom Set" if self.use_custom_set else "Default Set")
def assertEventSuccesful(self, arguments, event_name):
return self.assertEventsFromRun(
arguments=arguments, event_name=event_name, event_type="ended", min_count=1, max_count=1
)[0]
def assertEventsFromRun(
self, arguments, event_name, event_type, min_count=1, max_count=None, timeout=DEFAULT_TIMEOUT
):
events = self.fbsimctl.run(arguments, timeout)
matching_events = events.matching(event_name, event_type)
match_count = len(matching_events)
if min_count is not None:
self.assertGreaterEqual(
match_count,
min_count,
"Expected at least {} {} {} event, but there were {}. Other events: \b {}".format(
str(min_count), event_name, event_type, str(match_count), events
),
)
if max_count is not None:
self.assertLessEqual(
match_count,
max_count,
"Expected no more than {} {} {} event, but there were {}. Other events: \b {}".format(
str(max_count), event_name, event_type, str(match_count), events
),
)
return matching_events
def assertListContainsOnly(self, expected_udids, query=[]):
events = self.fbsimctl.run(query + ["list"])
list_events = events.matching("list", "discrete")
list_udids = [event.get("subject").get("udid") for event in list_events]
remainder = set(expected_udids) - set(list_udids)
self.assertEqual(len(remainder), 0, "Expected list command to contain {}, but it was missing".format(remainder))
additional = set(list_udids) - set(expected_udids)
self.assertEqual(
len(additional),
0,
"Expected list command only contain {}, but it had additional {}".format(expected_udids, additional),
)
return list_events
def assertExtractSimulator(self, json_event):
sim_json = json_event.get("subject")
self.assertIsNotNone(sim_json, "Expected {} to contain a simulator, but it did not".format(json_event))
return Simulator(sim_json)
def assertExtractAndKeyDiagnostics(self, json_events):
return {event["subject"]["short_name"]: event["subject"] for event in json_events}
def assertCreatesSimulator(self, args):
args = ["create"] + args
return self.assertExtractSimulator(self.assertEventSuccesful(args, "create"))
def testList(self):
self.fbsimctl(["list"])
def testCommandThatDoesNotExist(self):
with self.assertRaises(Exception):
self.fbsimctl(["foo"])
def setUp(self):
self.fbsimctl = FBSimctl(EXECUTABLE_PATH, self.provideSetPath())
class FBSimctlTestCase(unittest.TestCase):
def setUp(self):
self.fbsimctl = FBSimctl(EXECUTABLE_PATH, self.provideSetPath())
def provideSetPath(self):
return None
def assertEventSuccesful(self, arguments, event_name):
events = self.fbsimctl.run(arguments)
matching_events = events.matching(event_name, 'ended')
match_count = len(matching_events)
self.assertNotEqual(
0,
match_count,
'Expected one successful {} event, but there were none. Other events: \b {}'.format(
event_name,
events
)
)
self.assertLess(
match_count,
2,
'Expected one successful {} event, but there were {}. Matching events: \b {}'.format(
event_name,
str(match_count),
matching_events,
)
)
return matching_events[0]
def assertListContainsOnly(self, expected_udids):
events = self.fbsimctl.run(['list'])
list_events = events.matching('list', 'discrete')
list_udids = [
event.get('subject').get('udid') for event in list_events
]
remainder = set(expected_udids) - set(list_udids)
self.assertEqual(
len(remainder),
0,
'Expected list command to contain {}, but it was missing'.format(
remainder
)
)
additional = set(list_udids) - set(expected_udids)
self.assertEqual(
len(additional),
0,
'Expected list command only contain {}, but it had additional {}'.format(
expected_udids,
additional,
)
)
return list_events
def assertExtractSimulator(self, json_event):
sim_json = json_event.get('subject')
self.assertIsNotNone(
sim_json,
'Expected {} to contain a simulator, but it did not'.format(
json_event,
)
)
return Simulator(sim_json)
