def test_table_booking_mode_is_optional(self):
chart_key = self.create_test_chart_with_tables()
table_booking_config = TableBookingConfig.custom({"T1": "BY_TABLE", "T2": "BY_SEAT"})
season = self.client.seasons.create(chart_key, table_booking_config=table_booking_config)
assert_that(season.table_booking_config).is_equal_to(table_booking_config)
def test(self):
workspace = self.client.workspaces.create("a ws")
self.client.workspaces.set_default(workspace.key)
retrieved_workspace = self.client.workspaces.retrieve(workspace.key)
assert_that(retrieved_workspace.is_default).is_true()
def test_object_categories_is_optional(self):
chart_key = self.create_test_chart()
event = self.client.events.create(chart_key,
object_categories={'A-1': 10})
assert_that(event.object_categories).is_equal_to({'A-1': 10})
def test(self):
workspace = self.client.workspaces.create("a ws")
self.client.workspaces.deactivate(workspace.key)
retrieved_workspace = self.client.workspaces.retrieve(workspace.key)
assert_that(retrieved_workspace.is_active).is_false()
def test_number(self):
chart_key = self.create_test_chart()
event = self.client.events.create(chart_key)
result = self.client.events.change_best_available_object_status(
event.key, 3, "myStatus")
assert_that(result.next_to_each_other).is_true()
assert_that(result.objects).contains_exactly("B-4", "B-5", "B-6")
def A_native_function_can_edit_the_environment():
def mx3(env):
env.set("x", ("number", 3))
env = Env()
env.set("make_x_three", ("native", mx3))
assert_that(evald("x=1;make_x_three();x;", env), equals(("number", 3)))
def test_error_on_duplicate_key(self):
try:
chart_key = self.create_test_chart()
self.client.events.create_multiple(chart_key, [EventProperties(event_key="e1"), EventProperties(event_key="e1")])
self.fail("expected exception")
except SeatsioException as e:
assert_that(e.errors).is_not_empty()
def test_by_category_key(self):
report = self.client.charts.reports.by_category_key(self.chart_key)
assert_that(report.items).has_size(4)
assert_that(report.items['9']).has_size(17)
assert_that(report.items['10']).has_size(17)
assert_that(report.items['string11']).has_size(0)
assert_that(report.items['NO_CATEGORY']).has_size(0)
def A_closure_holds_updateable_values():
def dumb_set(env, sym, val):
env.parent.parent.parent.set(sym[1], val)
def dumb_if_equal(env, val1, val2, then_fn, else_fn):
if val1 == val2:
ret = then_fn
else:
ret = else_fn
return eval_expr(("call", ret, []), env)
env = Env()
env.set("dumb_set", ("native", dumb_set))
env.set("dumb_if_equal", ("native", dumb_if_equal))
assert_that(
evald(
"""
counter = {
x = 0;
{:(meth)
dumb_if_equal(meth, "get",
{x;},
{dumb_set("x", x + 1);}
);
}
}();
counter("inc");
counter("inc");
counter("get");
""", env), equals(("number", 2)))
def test(self):
chart = self.client.charts.create()
thumbnail = self.client.charts.retrieve_published_version_thumbnail(
chart.key)
assert_that(thumbnail).contains("PNG")
def testByLabel_BookWholeTablesFalse(self):
chart_key = self.create_test_chart_with_tables()
report = self.client.charts.reports.by_label(chart_key, 'false')
assert_that(report).is_instance(ChartReport)
assert_that(report.items).has_size(12)
def test_updateChannels(self):
chart = self.client.charts.create()
event = self.client.events.create(chart.key)
self.client.events.update_channels(
event.key, {
'channelKey1': Channel(
name='channel 1', color='#00FF00', index=1),
'channelKey2': Channel(
name='channel 2', color='#FF0000', index=2),
})
retrieved_event = self.client.events.retrieve(event.key)
assert_that(retrieved_event.channels).is_equal_to([
Channel(key='channelKey1',
name='channel 1',
color='#00FF00',
index=1,
objects=[]),
Channel(key='channelKey2',
name='channel 2',
color='#FF0000',
index=2,
objects=[])
])
def test_nameIsOptional(self):
subaccount = self.client.subaccounts.create("joske")
self.client.subaccounts.update(subaccount.id)
retrieved_subaccount = self.client.subaccounts.retrieve(subaccount.id)
assert_that(retrieved_subaccount.name).is_equal_to("joske")
def test(self):
subaccount = self.client.subaccounts.create("joske")
self.client.subaccounts.deactivate(subaccount.id)
retrieved_subaccount = self.client.subaccounts.retrieve(subaccount.id)
assert_that(retrieved_subaccount.active).is_false()
def test(self):
chart = self.client.charts.create("chartName")
published_drawing = self.client.charts.retrieve_published_version(
chart.key)
assert_that(published_drawing.name).is_equal_to("chartName")
def Multiple_token_types_can_be_combined():
assert_that(
lexed('frobnicate( "Hello" + name, 4 / 5.0);'),
equals([("symbol", "frobnicate"), ("(", ""), ("string", "Hello"),
("operation", "+"), ("symbol", "name"), (",", ""),
("number", "4"), ("operation", "/"), ("number", "5.0"),
(")", ""), (";", "")]))
def test(self):
chart = self.client.charts.create()
self.client.charts.move_to_archive(chart.key)
retrieved_chart = self.client.charts.retrieve(chart.key)
assert_that(retrieved_chart.archived).is_true()
def test(self):
chart = self.client.charts.create()
rulesets = {
'ruleset1':
SocialDistancingRuleset(
name='My first ruleset',
number_of_disabled_seats_to_the_sides=1,
disable_seats_in_front_and_behind=True,
disable_diagonal_seats_in_front_and_behind=True,
number_of_disabled_aisle_seats=2,
max_group_size=1,
max_occupancy_absolute=10,
max_occupancy_percentage=0,
one_group_per_table=True,
fixed_group_layout=False,
disabled_seats=["A-1"],
enabled_seats=["A-2"],
index=4),
'ruleset2':
SocialDistancingRuleset(name='My second ruleset'),
}
self.client.charts.save_social_distancing_rulesets(chart.key, rulesets)
retrieved_chart = self.client.charts.retrieve(chart.key)
assert_that(
retrieved_chart.social_distancing_rulesets).is_equal_to(rulesets)
def Function_definition_with_params_and_commands_gets_parsed():
assert_that(
parsed('{:(x,yy)print(3-4); a = "x"; print(a);};'),
equals(
[
(
"function",
[
("symbol", "x"),
("symbol", "yy")
],
[
(
"call",
("symbol", 'print'),
[
(
"operation",
'-',
("number", '3'),
("number", '4')
)
]
),
("assignment", ("symbol", 'a'), ("string", 'x')),
("call", ("symbol", 'print'), [("symbol", 'a')])
]
)
]
)
)
def The_str_of_a_value_is_its_repr():
@valueclass("m1", "m2", "m3")
class MyClass:
pass
x = MyClass(3, '4', 5)
assert_that(str(x), equals(repr(x)))
def Function_definition_containing_commands_gets_parsed():
assert_that(
parsed('{print(3-4); a = "x"; print(a);};'),
equals(
[
(
"function",
[],
[
(
"call",
("symbol", 'print'),
[
(
"operation",
'-',
("number", '3'),
("number", '4')
)
]
),
("assignment", ("symbol", 'a'), ("string", 'x')),
("call", ("symbol", 'print'), [("symbol", 'a')])
]
)
]
)
)
def Multiple_commands_parse_into_multiple_expressions():
program = """
x = 3;
func = {:(a) print(a);};
func(x);
"""
assert_that(
parsed(program),
equals(
[
("assignment", ("symbol", 'x'), ("number", '3')),
(
"assignment",
("symbol", 'func'),
(
"function",
[("symbol", 'a')],
[
("call", ("symbol", 'print'), [("symbol", 'a')])
]
)
),
("call", ("symbol", 'func'), [("symbol", 'x')])
]
)
)
def test_by_object_type(self):
report = self.client.charts.reports.by_object_type(self.chart_key)
assert_that(report.items).has_size(4)
assert_that(report.items['seat']).has_size(32)
assert_that(report.items['generalAdmission']).has_size(2)
assert_that(report.items['booth']).has_size(0)
assert_that(report.items['table']).has_size(0)
def A_closure_holds_updateable_values():
def dumb_set(env, sym, val):
env.parent.parent.parent.set(sym[1], val)
def dumb_if_equal(env, val1, val2, then_fn, else_fn):
if val1 == val2:
ret = then_fn
else:
ret = else_fn
return eval_expr(("call", ret, []), env)
env = Env()
env.set("dumb_set", ("native", dumb_set))
env.set("dumb_if_equal", ("native", dumb_if_equal))
assert_that(
evald(
"""
counter = {
x = 0;
{:(meth)
dumb_if_equal(meth, "get",
{x;},
{dumb_set("x", x + 1);}
);
}
}();
counter("inc");
counter("inc");
counter("get");
""",
env
),
equals(("number", 2))
)
def test_validate_draft_chart(self):
chart_key = self.create_test_chart_with_errors()
self.client.events.create(chart_key)
self.client.charts.update(chart_key, "New name")
validation = self.client.charts.validate_draft_version(chart_key)
assert_that(validation.errors).is_empty()
def A_symbol_within_a_function_has_the_local_value():
assert_that(
evald("""
foo = 3;
bar = {foo = 77;foo;}();
bar;
"""), equals(("number", 77)))
def Multiple_function_calls_with_various_args_get_parsed():
assert_that(
parsed("print( 'a', 3, 4 / 12 )(512)();"),
equals(
[
(
"call",
(
"call",
(
"call",
("symbol", "print"),
[
("string", "a"),
("number", "3"),
(
"operation",
"/",
("number", "4"),
("number", "12")
)
]
),
[
("number", "512")
]
),
[]
)
]
)
)
def Native_function_gets_called():
def native_fn(env, x, y):
return ("number", x[1] + y[1])
env = Env()
env.set("native_fn", ("native", native_fn))
assert_that(evald("native_fn( 2, 8 );", env), equals(("number", 10)))
def test_by_category_label(self):
report = self.client.charts.reports.by_category_label(self.chart_key)
assert_that(report.items).has_size(4)
assert_that(report.items['Cat1']).has_size(17)
assert_that(report.items['Cat2']).has_size(17)
assert_that(report.items['Cat3']).has_size(0)
assert_that(report.items['NO_CATEGORY']).has_size(0)
def test(self):
subaccount = self.client.subaccounts.create("joske")
self.client.subaccounts.update(subaccount.id, name="jefke")
retrieved_subaccount = self.client.subaccounts.retrieve(subaccount.id)
assert_that(retrieved_subaccount.name).is_equal_to("jefke")
def All_examples_evaluate():
from pycell.run import run
for example in all_examples():
with StringIO() as stdin, StringIO() as stdout:
run(example, stdin, stdout, stdout)
with open(example[:-5] + ".output.txt") as outputfile:
assert_that(stdout.getvalue(), equals(outputfile.read()))
def test(self):
subaccount = self.client.subaccounts.create()
self.client.subaccounts.regenerate_secret_key(subaccount.id)
retrieved_subaccount = self.client.subaccounts.retrieve(subaccount.id)
assert_that(retrieved_subaccount.secret_key).is_not_blank().is_not_equal_to(subaccount.secret_key)
def Can_hold_a_reference_to_a_function_and_call_it():
assert_that(
evald("""
add = {:(x, y) x + y;};
add(20, 2.2);
"""),
equals(("number", 22.2))
)
def Can_construct_a_nonempty_value_class_using_keyword_args():
@valueclass("mem1", "mem2")
class MyClass:
pass
b = MyClass(mem1=3, mem2=4)
assert_that(b.mem1, equals(3))
assert_that(b.mem2, equals(4))
def Can_construct_a_nonempty_value_class_using_positional_args():
@valueclass("mem1", "mem2")
class MyClass:
pass
b = MyClass(3, 4)
assert_that(b.mem1, equals(3))
assert_that(b.mem2, equals(4))
def Assigning_to_an_expression_is_an_error():
try:
parsed("x(4) = 5;")
fail("Should throw")
except Exception as e:
assert_that(
str(e),
equals("You can't assign to anything except a symbol.")
)
def Sum_of_numbers_is_parsed_as_expression():
assert_that(
parsed("32 + 44;"),
equals(
[
("operation", "+", ("number", "32"), ("number", "44"))
]
)
)
def Missing_param_definition_with_colon_is_an_error():
try:
parsed("{:print(x););")
fail("Should throw")
except Exception as e:
assert_that(
str(e),
equals("':' must be followed by '(' in a function.")
)
def The_repr_of_an_empty_value_can_be_used_to_make_an_equal_one():
@valueclass()
class MyClass:
pass
x = MyClass()
x_repr = repr(x)
y = eval(x_repr)
assert_that(x, equals(y))
def The_repr_of_a_nonempty_value_can_be_used_to_make_an_equal_one():
@valueclass("m1", "m2", "m3")
class MyClass:
pass
x = MyClass(3, '4', 5)
x_repr = repr(x)
y = eval(x_repr)
assert_that(x, equals(y))
def Multiplication_of_symbols_is_parsed_as_expression():
assert_that(
parsed("foo * bar;"),
equals(
[
("operation", "*", ("symbol", "foo"), ("symbol", "bar"))
]
)
)
def Difference_of_symbol_and_number_is_parsed_as_expression():
assert_that(
parsed("foo - 44;"),
equals(
[
("operation", "-", ("symbol", "foo"), ("number", "44"))
]
)
)
def Variable_assignment_gets_parsed():
assert_that(
parsed("x = 3;"),
equals(
[
("assignment", ("symbol", "x"), ("number", "3"))
]
)
)
def Function_call_with_no_args_gets_parsed():
assert_that(
parsed("print();"),
equals(
[
("call", ("symbol", "print"), [])
]
)
)
def A_symbol_within_a_function_has_the_local_value():
assert_that(
evald("""
foo = 3;
bar = {foo = 77;foo;}();
bar;
"""),
equals(("number", 77))
)
def A_native_function_can_edit_the_environment():
def mx3(env):
env.set("x", ("number", 3))
env = Env()
env.set("make_x_three", ("native", mx3))
assert_that(
evald("x=1;make_x_three();x;", env),
equals(("number", 3))
)
def Empty_function_definition_gets_parsed():
assert_that(
parsed("{};"),
equals(
[
("function", [], [])
]
)
)
def Multiple_function_calls_with_no_args_get_parsed():
assert_that(
parsed("print()();"),
equals(
[
("call", ("call", ("symbol", "print"), []), [])
]
)
)
def Defining_function_with_js_keyword_name_mangles_it():
assert_that(
compiled("for = {7 + 3;};for();"),
equals("""var for__ = (function() {
return 7 + 3;
});
for__();
""")
)
def Items_separated_by_newlines_become_separate_tokens():
assert_that(
lexed("foo\nbar"),
equals(
[
("symbol", "foo"),
("symbol", "bar")
]
)
)
def All_examples_evaluate():
from pycell.run import run
for example in all_examples():
try:
with StringIO() as stdin, StringIO() as stdout:
run(example, stdin, stdout, stdout)
with open(example[:-5] + ".output.txt") as outputfile:
assert_that(stdout.getvalue(), equals(outputfile.read()))
except Exception as e:
raise Exception("%s: %s" % (example, str(e)))
def Values_of_different_types_with_the_same_members_are_not_equal():
@valueclass("m1", "m2", "m3")
class MyClass1:
pass
@valueclass("m1", "m2", "m3")
class MyClass2:
pass
assert_that(MyClass1("a", 3, None), is_not(MyClass2("a", 3, None)))
def Empty_value_classes_compare_not_equal_if_different_class():
@valueclass()
class MyClass1:
pass
@valueclass()
class MyClass2:
pass
assert_that(MyClass1(), is_not(MyClass2()))
def Symbols_may_start_with_underscores():
assert_that(
lexed("_foo2_bar ( "),
equals(
[
("symbol", "_foo2_bar"),
("(", "")
]
)
)
def Symbols_may_contain_numbers_and_underscores():
assert_that(
lexed("foo2_bar ( "),
equals(
[
("symbol", "foo2_bar"),
("(", "")
]
)
)
def Compiling_use_of_if_renders_immediately_called_function():
assert_that(
compiled("if(1, {'true'}, {'false'});"),
equals("""(function() {
if( 1 !== 0 ) {
return 'true';
} else {
return 'false';
}
})();\n""")
)
