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""") )