From d4b9af2918484eeaf39f3267568a238bac112a94 Mon Sep 17 00:00:00 2001 From: Oliver Linnarsson Date: Tue, 18 Jun 2024 13:18:35 +0200 Subject: [PATCH] test: Rename test cases --- .gitignore | 1 + test/unit_tests/engine_test.gleam | 18 +++++++++--------- test/unit_tests/format_test.gleam | 4 ++-- test/unit_tests/parser_test.gleam | 12 ++++++------ test/unit_tests/tokenizer_test.gleam | 16 ++++++++-------- test/user_stories/hello_test.gleam | 6 +++--- test/user_stories/knattarna_test.gleam | 6 +++--- test/user_stories/nested_block.gleam | 6 +++--- 8 files changed, 35 insertions(+), 34 deletions(-) diff --git a/.gitignore b/.gitignore index 599be4e..18c440a 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ *.ez /build erl_crash.dump +.DS_Store diff --git a/test/unit_tests/engine_test.gleam b/test/unit_tests/engine_test.gleam index e9bd7b8..529af9b 100644 --- a/test/unit_tests/engine_test.gleam +++ b/test/unit_tests/engine_test.gleam @@ -4,14 +4,14 @@ import handles/ctx import handles/internal/engine import handles/internal/parser -pub fn engine_should_return_correct_when_running_hello_world_test() { +pub fn hello_world_test() { [parser.Constant("Hello World")] |> engine.run(ctx.Dict([]), string_builder.new()) |> should.be_ok |> should.equal("Hello World") } -pub fn engine_should_return_correct_when_running_hello_name_test() { +pub fn hello_name_test() { [parser.Constant("Hello "), parser.Property(["name"])] |> engine.run( ctx.Dict([ctx.Prop("name", ctx.Str("Oliver"))]), @@ -21,7 +21,7 @@ pub fn engine_should_return_correct_when_running_hello_name_test() { |> should.equal("Hello Oliver") } -pub fn engine_should_return_correct_when_accessing_nested_property_test() { +pub fn nested_property_test() { [parser.Property(["foo", "bar"])] |> engine.run( ctx.Dict([ctx.Prop("foo", ctx.Dict([ctx.Prop("bar", ctx.Int(42))]))]), @@ -31,7 +31,7 @@ pub fn engine_should_return_correct_when_accessing_nested_property_test() { |> should.equal("42") } -pub fn engine_should_return_correct_when_using_truthy_if_test() { +pub fn truthy_if_test() { [parser.IfBlock(["bool"], [parser.Property(["foo", "bar"])])] |> engine.run( ctx.Dict([ @@ -44,7 +44,7 @@ pub fn engine_should_return_correct_when_using_truthy_if_test() { |> should.equal("42") } -pub fn engine_should_return_correct_when_using_falsy_if_test() { +pub fn falsy_if_test() { [parser.IfBlock(["bool"], [parser.Property(["foo", "bar"])])] |> engine.run( ctx.Dict([ctx.Prop("bool", ctx.Bool(False))]), @@ -54,7 +54,7 @@ pub fn engine_should_return_correct_when_using_falsy_if_test() { |> should.equal("") } -pub fn engine_should_return_correct_when_using_truthy_unless_test() { +pub fn truthy_unless_test() { [parser.UnlessBlock(["bool"], [parser.Property(["foo", "bar"])])] |> engine.run( ctx.Dict([ctx.Prop("bool", ctx.Bool(True))]), @@ -64,7 +64,7 @@ pub fn engine_should_return_correct_when_using_truthy_unless_test() { |> should.equal("") } -pub fn engine_should_return_correct_when_using_falsy_unless_test() { +pub fn falsy_unless_test() { [parser.UnlessBlock(["bool"], [parser.Property(["foo", "bar"])])] |> engine.run( ctx.Dict([ @@ -77,7 +77,7 @@ pub fn engine_should_return_correct_when_using_falsy_unless_test() { |> should.equal("42") } -pub fn engine_should_return_correct_when_using_each_test() { +pub fn each_test() { [ parser.Constant("They are "), parser.EachBlock(["list"], [ @@ -103,7 +103,7 @@ pub fn engine_should_return_correct_when_using_each_test() { |> should.equal("They are Knatte, Fnatte, Tjatte, and Kalle") } -pub fn engine_should_return_correct_when_using_empty_each_test() { +pub fn empty_each_test() { [ parser.EachBlock(["list"], [ parser.Property(["name"]), diff --git a/test/unit_tests/format_test.gleam b/test/unit_tests/format_test.gleam index 45143d0..393a48d 100644 --- a/test/unit_tests/format_test.gleam +++ b/test/unit_tests/format_test.gleam @@ -2,7 +2,7 @@ import gleeunit/should import handles/format import handles/internal/tokenizer -pub fn format_should_return_correct_string_for_unexpected_token_test() { +pub fn unexpected_token_test() { let template = "{{foo}d" tokenizer.run(template, 0, []) |> should.be_error @@ -11,7 +11,7 @@ pub fn format_should_return_correct_string_for_unexpected_token_test() { |> should.equal("Tag is missing closing braces }} (row=0, col=2)") } -pub fn format_should_return_correct_string_for_unexpected_end_of_template_test() { +pub fn unexpected_end_of_template_test() { let template = "{{foo}" tokenizer.run(template, 0, []) |> should.be_error diff --git a/test/unit_tests/parser_test.gleam b/test/unit_tests/parser_test.gleam index c1ac763..6044282 100644 --- a/test/unit_tests/parser_test.gleam +++ b/test/unit_tests/parser_test.gleam @@ -2,37 +2,37 @@ import gleeunit/should import handles/internal/parser import handles/internal/tokenizer -pub fn parser_should_return_correct_when_compiling_no_tokens_test() { +pub fn no_tokens_test() { [] |> parser.run([]) |> should.equal([]) } -pub fn parser_should_return_correct_when_compiling_one_constant_test() { +pub fn one_constant_test() { [tokenizer.Constant("Hello World")] |> parser.run([]) |> should.equal([parser.Constant("Hello World")]) } -pub fn parser_should_return_correct_when_compiling_one_property_test() { +pub fn one_property_test() { [tokenizer.Property(["foo", "bar"])] |> parser.run([]) |> should.equal([parser.Property(["foo", "bar"])]) } -pub fn parser_should_return_correct_when_compiling_one_ifblock_test() { +pub fn one_ifblock_test() { [tokenizer.IfBlockStart(["bar", "biz"]), tokenizer.IfBlockEnd] |> parser.run([]) |> should.equal([parser.IfBlock(["bar", "biz"], [])]) } -pub fn parser_should_return_correct_when_compiling_one_unlessblock_test() { +pub fn one_unlessblock_test() { [tokenizer.UnlessBlockStart(["bar", "biz"]), tokenizer.UnlessBlockEnd] |> parser.run([]) |> should.equal([parser.UnlessBlock(["bar", "biz"], [])]) } -pub fn parser_should_return_correct_when_compiling_one_eachblock_test() { +pub fn one_eachblock_test() { [tokenizer.EachBlockStart(["bar", "biz"]), tokenizer.EachBlockEnd] |> parser.run([]) |> should.equal([parser.EachBlock(["bar", "biz"], [])]) diff --git a/test/unit_tests/tokenizer_test.gleam b/test/unit_tests/tokenizer_test.gleam index 34973c9..ddcfd4b 100644 --- a/test/unit_tests/tokenizer_test.gleam +++ b/test/unit_tests/tokenizer_test.gleam @@ -2,21 +2,21 @@ import gleeunit/should import handles/error import handles/internal/tokenizer -pub fn tokenizer_should_return_correct_when_parsing_empty_string_test() { +pub fn empty_string_test() { "" |> tokenizer.run(0, []) |> should.be_ok |> should.equal([]) } -pub fn tokenizer_should_return_correct_when_passed_one_tag_test() { +pub fn one_tag_test() { "{{foo}}" |> tokenizer.run(0, []) |> should.be_ok |> should.equal([tokenizer.Property(["foo"])]) } -pub fn tokenizer_should_return_correct_when_passed_two_tags_test() { +pub fn two_tags_test() { "{{foo}} {{bar}}" |> tokenizer.run(0, []) |> should.be_ok @@ -27,35 +27,35 @@ pub fn tokenizer_should_return_correct_when_passed_two_tags_test() { ]) } -pub fn tokenizer_should_return_lex_error_when_unexpected_token_test() { +pub fn unexpected_token_test() { "{{foo}d" |> tokenizer.run(0, []) |> should.be_error |> should.equal(error.UnbalancedTag(2)) } -pub fn tokenizer_should_return_lex_error_when_unexpected_end_of_template_test() { +pub fn unexpected_end_of_template_test() { "{{foo}" |> tokenizer.run(0, []) |> should.be_error |> should.equal(error.UnbalancedTag(2)) } -pub fn compiler_should_return_error_when_missing_block_kind_test() { +pub fn missing_block_argument_test() { "{{#if}}" |> tokenizer.run(0, []) |> should.be_error |> should.equal(error.MissingBlockArgument(2)) } -pub fn compiler_should_return_error_when_providing_arguments_to_end_block_test() { +pub fn end_block_with_arguments_test() { "{{/if bar}}" |> tokenizer.run(0, []) |> should.be_error |> should.equal(error.UnexpectedBlockArgument(2)) } -pub fn compiler_should_return_error_when_providing_empty_expression_test() { +pub fn empty_expression_test() { "{{}}" |> tokenizer.run(0, []) |> should.be_error diff --git a/test/user_stories/hello_test.gleam b/test/user_stories/hello_test.gleam index 62be203..d6e3910 100644 --- a/test/user_stories/hello_test.gleam +++ b/test/user_stories/hello_test.gleam @@ -20,18 +20,18 @@ const expected_ast = [ const expected_output = "Hello Oliver!" -pub fn tokenizer_should_return_correct_for_user_story_helloworld_test() { +pub fn tokenizer_test() { tokenizer.run(input_template, 0, []) |> should.be_ok |> should.equal(expected_tokens) } -pub fn parser_should_return_correct_for_user_story_helloworld_test() { +pub fn parser_test() { parser.run(expected_tokens, []) |> should.equal(expected_ast) } -pub fn engine_should_return_correct_for_user_story_helloworld_test() { +pub fn engine_test() { engine.run(expected_ast, input_context, string_builder.new()) |> should.be_ok |> should.equal(expected_output) diff --git a/test/user_stories/knattarna_test.gleam b/test/user_stories/knattarna_test.gleam index a22a435..746efb2 100644 --- a/test/user_stories/knattarna_test.gleam +++ b/test/user_stories/knattarna_test.gleam @@ -38,18 +38,18 @@ const expected_ast = [ const expected_output = "They are Knatte, Fnatte, Tjatte, and Kalle" -pub fn tokenizer_should_return_correct_for_user_story_knattarna_test() { +pub fn tokenizer_test() { tokenizer.run(input_template, 0, []) |> should.be_ok |> should.equal(expected_tokens) } -pub fn parser_should_return_correct_for_user_story_knattarna_test() { +pub fn parser_test() { parser.run(expected_tokens, []) |> should.equal(expected_ast) } -pub fn engine_should_return_correct_for_user_story_knattarna_test() { +pub fn engine_test() { engine.run(expected_ast, input_context, string_builder.new()) |> should.be_ok |> should.equal(expected_output) diff --git a/test/user_stories/nested_block.gleam b/test/user_stories/nested_block.gleam index a80912c..19365b3 100644 --- a/test/user_stories/nested_block.gleam +++ b/test/user_stories/nested_block.gleam @@ -59,18 +59,18 @@ const expected_ast = [ const expected_output = "1212" -pub fn tokenizer_should_return_correct_for_user_story_nested_test() { +pub fn tokenizer_test() { tokenizer.run(input_template, 0, []) |> should.be_ok |> should.equal(expected_tokens) } -pub fn parser_should_return_correct_for_user_story_nested_test() { +pub fn parser_test() { parser.run(expected_tokens, []) |> should.equal(expected_ast) } -pub fn engine_should_return_correct_for_user_story_nested_test() { +pub fn engine_test() { engine.run(expected_ast, input_context, string_builder.new()) |> should.be_ok |> should.equal(expected_output)