Skip to content

Removed FluentAssertions #17

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
dusrdev merged 3 commits into from
Jan 16, 2025
Merged

Removed FluentAssertions #17

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
5e266f4
Removed FluentAssertions from Sharpify.Test
dusrdev Jan 16, 2025
a07a815
Removed FluentAssertions from Sharpify.Data
dusrdev Jan 16, 2025
b7f6bd7
Removed FluentAssertions from Sharpify.CLI
dusrdev Jan 16, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
160 changes: 80 additions & 80 deletions tests/Sharpify.CommandLineInterface.Tests/ArgumentsIsolatedTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,16 +9,16 @@ public class ArgumentsIsolatedTests {
[Fact]
public void Arguments_Positional_BeforeForwarding() {
// Positional 0 [Command]
Args.TryGetValue(0, out var pos0).Should().BeTrue();
pos0.Should().Be("command");
Assert.True(Args.TryGetValue(0, out var pos0));
Assert.Equal("command", pos0);

// Positional 0 [positional]
Args.TryGetValue(1, out var pos1).Should().BeTrue();
pos1.Should().Be("positional");
Assert.True(Args.TryGetValue(1, out var pos1));
Assert.Equal("positional", pos1);

// Positional 0 [positional2]
Args.TryGetValue(2, out var pos2).Should().BeTrue();
pos2.Should().Be("positional2");
Assert.True(Args.TryGetValue(2, out var pos2));
Assert.Equal("positional2", pos2);
}

[Fact]
Expand All @@ -29,24 +29,24 @@ public void Arguments_Positional_AfterForwarding() {
// positional should be at 0, and positional2 at 1.

// Positional 0 [positional]
forwarded.TryGetValue(0, out var pos0).Should().BeTrue();
pos0.Should().Be("positional");
Assert.True(forwarded.TryGetValue(0, out var pos0));
Assert.Equal("positional", pos0);

// Positional 1 [positional2]
forwarded.TryGetValue(1, out var pos1).Should().BeTrue();
pos1.Should().Be("positional2");
Assert.True(forwarded.TryGetValue(1, out var pos1));
Assert.Equal("positional2", pos1);
}

[Fact]
public void Arguments_Named_BeforeForwarding() {
// named1 - Harold
// named2 - Finch

Args.TryGetValue("named1", out var firstName).Should().BeTrue();
firstName.Should().Be("Harold");
Assert.True(Args.TryGetValue("named1", out var firstName));
Assert.Equal("Harold", firstName);

Args.TryGetValue("named2", out var lastName).Should().BeTrue();
lastName.Should().Be("Finch");
Assert.True(Args.TryGetValue("named2", out var lastName));
Assert.Equal("Finch", lastName);
}

[Fact]
Expand All @@ -56,214 +56,214 @@ public void Arguments_Named_AfterForwarding() {
// named1 - Harold
// named2 - Finch

forwarded.TryGetValue("named1", out var firstName).Should().BeTrue();
firstName.Should().Be("Harold");
Assert.True(forwarded.TryGetValue("named1", out var firstName));
Assert.Equal("Harold", firstName);

forwarded.TryGetValue("named2", out var lastName).Should().BeTrue();
lastName.Should().Be("Finch");
Assert.True(forwarded.TryGetValue("named2", out var lastName));
Assert.Equal("Finch", lastName);
}

[Fact]
public void Arguments_Flag_BeforeForwarding() {
Args.HasFlag("flag").Should().BeTrue();
Assert.True(Args.HasFlag("flag"));
}

[Fact]
public void Arguments_Flag_AfterForwarding() {
var forwarded = Args.ForwardPositionalArguments();
forwarded.HasFlag("flag").Should().BeTrue();
Assert.True(forwarded.HasFlag("flag"));
}

[Fact]
public void Arguments_Contains_Key() {
Args.Contains("named1").Should().BeTrue();
Assert.True(Args.Contains("named1"));
}

[Fact]
public void Arguments_Contains_Position() {
Args.Contains(0).Should().BeTrue();
Assert.True(Args.Contains(0));
}

[Fact]
public void Arguments_Named_Array_String() {
Args.TryGetValues("words", "|", out var words).Should().BeTrue();
words.Should().BeEquivalentTo(["word1", "word2"]);
Assert.True(Args.TryGetValues("words", "|", out var words));
Assert.Equal(["word1", "word2"], words);
}

[Fact]
public void Arguments_Named_MultipleKeys_Array_String() {
var args = Parser.ParseArguments("command --words word1|word2")!;
args.TryGetValues(["words", "w"], "|", out var words).Should().BeTrue();
words.Should().BeEquivalentTo(["word1", "word2"]);
Assert.True(args.TryGetValues(["words", "w"], "|", out var words));
Assert.Equal(["word1", "word2"], words);
args = Parser.ParseArguments("command --w word1|word2")!;
args.TryGetValues(["words", "w"], "|", out var w).Should().BeTrue();
w.Should().BeEquivalentTo(["word1", "word2"]);
Assert.True(args.TryGetValues(["words", "w"], "|", out var w));
Assert.Equal(["word1", "word2"], w);
}

[Fact]
public void Arguments_Named_MultipleKeys_Array_Int() {
var args = Parser.ParseArguments("command --numbers 1|2")!;
args.TryGetValues<int>(["numbers", "n"], "|", out var numbers).Should().BeTrue();
numbers.Should().BeEquivalentTo([1, 2]);
Assert.True(args.TryGetValues<int>(["numbers", "n"], "|", out var numbers));
Assert.Equal([1, 2], numbers);
args = Parser.ParseArguments("command -n 1|2")!;
args.TryGetValues<int>(["numbers", "n"], "|", out var n).Should().BeTrue();
n.Should().BeEquivalentTo([1, 2]);
Assert.True(args.TryGetValues<int>(["numbers", "n"], "|", out var n));
Assert.Equal([1, 2], n);
}

[Fact]
public void Arguments_Positional_Array_String() {
var args = Parser.ParseArguments("command q1|q2")!;
args.TryGetValues(1, "|", out var words).Should().BeTrue();
words.Should().BeEquivalentTo(["q1", "q2"]);
Assert.True(args.TryGetValues(1, "|", out var words));
Assert.Equal(["q1", "q2"], words);
}

[Fact]
public void Arguments_Named_Array_Int() {
Args.TryGetValues<int>("numbers", "|", out var numbers).Should().BeTrue();
numbers.Should().BeEquivalentTo([1, 2]);
Assert.True(Args.TryGetValues<int>("numbers", "|", out var numbers));
Assert.Equal([1, 2], numbers);
}

[Fact]
public void Arguments_Positional_Array_Int() {
var args = Parser.ParseArguments("command 1|2")!;
args.TryGetValues<int>(1, "|", out var numbers).Should().BeTrue();
numbers.Should().BeEquivalentTo([1, 2]);
Assert.True(args.TryGetValues<int>(1, "|", out var numbers));
Assert.Equal([1, 2], numbers);
}

[Fact]
public void Arguments_TryGetValue_Named_Int() {
var args = Parser.ParseArguments("command -x 5 -y Hello")!;
args.TryGetValue("x", 0, out int x).Should().BeTrue();
x.Should().Be(5);
args.TryGetValue("y", 0, out int y).Should().BeFalse();
y.Should().Be(0);
Assert.True(args.TryGetValue("x", 0, out int x));
Assert.Equal(5, x);
Assert.False(args.TryGetValue("y", 0, out int y));
Assert.Equal(0, y);
}

[Fact]
public void Arguments_TryGetValue_Named_Double() {
var args = Parser.ParseArguments("command -x 5 -y Hello")!;
args.TryGetValue("x", 0, out double x).Should().BeTrue();
x.Should().Be(5);
args.TryGetValue("y", 0, out double y).Should().BeFalse();
y.Should().Be(0);
Assert.True(args.TryGetValue("x", 0, out double x));
Assert.Equal(5, x);
Assert.False(args.TryGetValue("y", 0, out double y));
Assert.Equal(0, y);
}

[Fact]
public void Arguments_GetValue_Named_Int() {
var args = Parser.ParseArguments("command -x 5 -y Hello")!;
args.GetValue("x", 0).Should().Be(5);
args.GetValue("y", 0).Should().Be(0);
Assert.Equal(5, args.GetValue("x", 0));
Assert.Equal(0, args.GetValue("y", 0));
}

[Fact]
public void Arguments_GetValue_Named_MultipleKeys_Int() {
var args = Parser.ParseArguments("command -x 5 -y Hello")!;
args.GetValue(["x", "one"], 0).Should().Be(5);
Assert.Equal(5, args.GetValue(["x", "one"], 0));
args = Parser.ParseArguments("command --one 5 -y Hello")!;
args.GetValue(["x", "one"], 0).Should().Be(5);
Assert.Equal(5, args.GetValue(["x", "one"], 0));
}

[Fact]
public void Arguments_TryGetValue_Positional_Int() {
var args = Parser.ParseArguments("command 5 Hello")!;
args.TryGetValue(1, 0, out double x).Should().BeTrue();
x.Should().Be(5);
args.TryGetValue(2, 0, out double y).Should().BeFalse();
y.Should().Be(0);
Assert.True(args.TryGetValue(1, 0, out double x));
Assert.Equal(5, x);
Assert.False(args.TryGetValue(2, 0, out double y));
Assert.Equal(0, y);
}

[Fact]
public void Arguments_GetValue_Positional_Int() {
var args = Parser.ParseArguments("command 5 Hello")!;
args.GetValue(1, 0).Should().Be(5);
args.GetValue(2, 0).Should().Be(0);
Assert.Equal(5, args.GetValue(1, 0));
Assert.Equal(0, args.GetValue(2, 0));
}

[Fact]
public void Arguments_TryGetEnum_Positional() {
var args = Parser.ParseArguments("command Blue")!;
args.TryGetEnum(1, out ConsoleColor color).Should().BeTrue();
color.Should().Be(ConsoleColor.Blue);
Assert.True(args.TryGetEnum(1, out ConsoleColor color));
Assert.Equal(ConsoleColor.Blue, color);
}

[Fact]
public void Arguments_TryGetEnum_Positional_IgnoreCase() {
var args = Parser.ParseArguments("command bLue")!;
args.TryGetEnum(1, true, out ConsoleColor color).Should().BeTrue();
color.Should().Be(ConsoleColor.Blue);
Assert.True(args.TryGetEnum(1, true, out ConsoleColor color));
Assert.Equal(ConsoleColor.Blue, color);
}

[Fact]
public void Arguments_TryGetEnum_Named() {
var args = Parser.ParseArguments("command --color Blue")!;
args.TryGetEnum("color", out ConsoleColor color).Should().BeTrue();
color.Should().Be(ConsoleColor.Blue);
Assert.True(args.TryGetEnum("color", out ConsoleColor color));
Assert.Equal(ConsoleColor.Blue, color);
}

[Fact]
public void Arguments_TryGetEnum_Named_IgnoreCase() {
var args = Parser.ParseArguments("command --color bLue")!;
args.TryGetEnum("color", true, out ConsoleColor color).Should().BeTrue();
color.Should().Be(ConsoleColor.Blue);
Assert.True(args.TryGetEnum("color", true, out ConsoleColor color));
Assert.Equal(ConsoleColor.Blue, color);
}

[Fact]
public void Arguments_TryGetEnum_Named_MultipleKeys() {
var args = Parser.ParseArguments("command --color Blue")!;
args.TryGetEnum(["color", "c"], out ConsoleColor color).Should().BeTrue();
color.Should().Be(ConsoleColor.Blue);
Assert.True(args.TryGetEnum(["color", "c"], out ConsoleColor color));
Assert.Equal(ConsoleColor.Blue, color);
args = Parser.ParseArguments("command -c Blue")!;
args.TryGetEnum(["color", "c"], out ConsoleColor c).Should().BeTrue();
c.Should().Be(ConsoleColor.Blue);
Assert.True(args.TryGetEnum(["color", "c"], out ConsoleColor c));
Assert.Equal(ConsoleColor.Blue, c);
}

[Fact]
public void Arguments_TryGetEnum_Named_MultipleKeys_IgnoreCase() {
var args = Parser.ParseArguments("command --color bLue")!;
args.TryGetEnum(["color", "c"], true, out ConsoleColor color).Should().BeTrue();
color.Should().Be(ConsoleColor.Blue);
Assert.True(args.TryGetEnum(["color", "c"], true, out ConsoleColor color));
Assert.Equal(ConsoleColor.Blue, color);
args = Parser.ParseArguments("command -c bLue")!;
args.TryGetEnum(["color", "c"], true, out ConsoleColor c).Should().BeTrue();
c.Should().Be(ConsoleColor.Blue);
Assert.True(args.TryGetEnum(["color", "c"], true, out ConsoleColor c));
Assert.Equal(ConsoleColor.Blue, c);
}

[Fact]
public void Arguments_GetEnum_Positional() {
var args = Parser.ParseArguments("command Blue")!;
args.GetEnum(1, ConsoleColor.Black).Should().Be(ConsoleColor.Blue);
Assert.Equal(ConsoleColor.Blue, args.GetEnum(1, ConsoleColor.Black));
}

[Fact]
public void Arguments_GetEnum_Positional_IgnoreCase() {
var args = Parser.ParseArguments("command bLue")!;
args.GetEnum(1, ConsoleColor.Black, true).Should().Be(ConsoleColor.Blue);
Assert.Equal(ConsoleColor.Blue, args.GetEnum(1, ConsoleColor.Black, true));
}

[Fact]
public void Arguments_GetEnum_Named() {
var args = Parser.ParseArguments("command --color Blue")!;
args.GetEnum("color", ConsoleColor.Black).Should().Be(ConsoleColor.Blue);
Assert.Equal(ConsoleColor.Blue, args.GetEnum("color", ConsoleColor.Black));
}

[Fact]
public void Arguments_GetEnum_Named_IgnoreCase() {
var args = Parser.ParseArguments("command --color bLue")!;
args.GetEnum("color", ConsoleColor.Black, true).Should().Be(ConsoleColor.Blue);
Assert.Equal(ConsoleColor.Blue, args.GetEnum("color", ConsoleColor.Black, true));
}

[Fact]
public void Arguments_GetEnum_Named_MultipleKeys() {
var args = Parser.ParseArguments("command --color Blue")!;
args.GetEnum(["color", "c"], ConsoleColor.Black).Should().Be(ConsoleColor.Blue);
Assert.Equal(ConsoleColor.Blue, args.GetEnum(["color", "c"], ConsoleColor.Black));
args = Parser.ParseArguments("command -c Blue")!;
args.GetEnum(["color", "c"], ConsoleColor.Black).Should().Be(ConsoleColor.Blue);
Assert.Equal(ConsoleColor.Blue, args.GetEnum(["color", "c"], ConsoleColor.Black));
}

[Fact]
public void Arguments_GetEnum_Named_MultipleKeys_IgnoreCase() {
var args = Parser.ParseArguments("command --color bLue")!;
args.GetEnum(["color", "c"], ConsoleColor.Black, true).Should().Be(ConsoleColor.Blue);
Assert.Equal(ConsoleColor.Blue, args.GetEnum(["color", "c"], ConsoleColor.Black, true));
args = Parser.ParseArguments("command -c bLue")!;
args.GetEnum(["color", "c"], ConsoleColor.Black, true).Should().Be(ConsoleColor.Blue);
Assert.Equal(ConsoleColor.Blue, args.GetEnum(["color", "c"], ConsoleColor.Black, true));
}
}
Loading
Loading