DiscordApi/Discord.API.Tests/JsonTests.cs

using System.Text.Json;
using Newtonsoft.Json;
using Xunit.Abstractions;
using JsonSerializer = System.Text.Json.JsonSerializer;

namespace Discord.API.Tests;
using Xunit;
using Discord.API;

public class JsonTests
{
    private readonly ITestOutputHelper _testOutputHelper;

    public JsonTests(ITestOutputHelper testOutputHelper)
    {
        _testOutputHelper = testOutputHelper;
    }

    [Fact]
    public void InvalidSessionDeserialize()
    {
        string src = """
                     {
                       "op": 9
                     }
                     """;
        GatewayPacket? gateway_packet = JsonSerializer.Deserialize(src, SourceGenerationContext.Default.GatewayPacket);
        Assert.IsType<InvalidSessionPacket>(gateway_packet);
    }
    
    [Fact]
    public void ReconnectPacketDeserialize()
    {
        string src = """
                     {
                       "op": 7,
                       "d": null
                     }
                     """;
        GatewayPacket? gateway_packet = JsonSerializer.Deserialize(src, SourceGenerationContext.Default.GatewayPacket);

        Assert.IsType<ReconnectPacket>(gateway_packet);
    }
    
    [Fact]
    public void ResumePacketSerialize()
    {
        ResumePacket gateway_packet = new()
        {
            Data = new()
            {
                Token = "tokenlol",
                Sequence = 10,
                SessionId = "sessionlol69"
            }
        };

        string serialized = JsonSerializer.Serialize(gateway_packet, SourceGenerationContext.Default.GatewayPacket);
        
        _testOutputHelper.WriteLine($"Serilazed Resume packet: {serialized}");
        
        //TODO: Verify the string
    }
    
    [Fact]
    public void HelloPacketDeserialize()
    {
        string src = """
                     {
                       "op": 10,
                       "d": {
                         "heartbeat_interval": 45000
                       }
                     }
                     """;

        GatewayPacket? gateway_packet = JsonSerializer.Deserialize(src, SourceGenerationContext.Default.GatewayPacket);
        Assert.IsType<HelloPacket>(gateway_packet);
        Assert.True(gateway_packet is HelloPacket
        {
            Op: GatewayPacket.Opcode.Hello,
            Data.HeartbeatInterval: 45000
        });
    }
    
    [Fact]
    public void HeartbeatAckDeserialize()
    {
        string src = """
                     {"op":11}
                     """;

        GatewayPacket? gateway_packet = JsonSerializer.Deserialize(src, SourceGenerationContext.Default.GatewayPacket);

        Assert.IsType<HeartbeatAckPacket>(gateway_packet);
        Assert.Equal(GatewayPacket.Opcode.HeartbeatAck, gateway_packet.Op);
    }
    
    [Fact]
    public void HeartbeatPacketSerialize()
    {
        HeartbeatPacket heartbeat_packet = new()
        {
            Sequence = 69
        };
        string serialized = JsonSerializer.Serialize(heartbeat_packet, SourceGenerationContext.Default.GatewayPacket);

        JsonDocument json_doc = JsonDocument.Parse(serialized);
        Assert.True(json_doc.RootElement.TryGetProperty("op", out var opcode) &&
                    opcode.ValueKind == JsonValueKind.Number &&
                    opcode.TryGetInt32(out int op) && op == (int)GatewayPacket.Opcode.Heartbeat);
        
        Assert.True(json_doc.RootElement.TryGetProperty("d", out var sequence) &&
                    sequence.ValueKind == JsonValueKind.Number &&
                    sequence.TryGetUInt64(out ulong seq) && seq == 69);
    }
    
    [Fact]
    public void IdentifyPacketSerialize()
    {
        IdentifyPacket identify_packet = new()
        {
            Data = new()
            {
                Token = "token_lol",
                Intents = 6969,
                Shard = [1, 2],
                LargeThreshold = 42
            }
        };

        string serialized =
            JsonSerializer.Serialize(identify_packet, SourceGenerationContext.Default.GatewayPacket);
        
        _testOutputHelper.WriteLine($"Serialized Identify packet: {serialized}");
        
        //TODO: Test the output string
    }
    
    [Fact]
    public void ReadyPacketDeserialize()
    {
        const string src = """
                            {
                                "op":0,
                                "t":"READY",
                                "s":1,
                                "d":{
                                    "v":10,
                                    "user":{
                                        "id":"1234",
                                        "username":"abrakadabra",
                                        "discriminator":"1111",
                                        "global_name":"glblname"
                                    },
                                    "guilds":[
                                        {
                                            "id":"5678",
                                            "unavailable":true
                                        }
                                    ],
                                    "session_id":"abcd",
                                    "resume_gateway_url":"dfgh",
                                    "application":{
                                        "id":"3333",
                                        "flags":5555
                                    }
                                }
                           }
                           """;
        GatewayPacket? packet =
            JsonSerializer.Deserialize<GatewayPacket>(src, SourceGenerationContext.Default.GatewayPacket);

        Assert.NotNull(packet);
        Assert.IsType<ReadyPacket>(packet);
        
        Assert.True(packet is ReadyPacket
        {
            Op: GatewayPacket.Opcode.Dispatch,
            Event: "READY",
            Sequence: 1,
            Data:
            {
                User:
                {
                    Id:1234,
                    Username: "abrakadabra",
                    Discriminator: "1111",
                    GlobalName: "glblname"
                },
                Version: 10,
                SessionId: "abcd",
                ResumeGatewayUrl: "dfgh",
                Guilds:[
                    {
                        Id: 5678,
                        Unavailable: true
                    }
                ],
                Application:
                {
                    Id: 3333,
                    Flags: 5555
                }
            }
        });
    }
    
    [Fact]
    public void ChannelCreateDeserialize()
    {
        string src = """
                     {
                         "op":0,
                         "t":"CHANNEL_CREATE",
                         "s":1,
                         "d":{
                            "id": "922243411795390570",
                            "type": 2,
                            "guild_id": "5678",
                            "position": 3,
                            "name": "voice csennel",
                            "topic": "A very interesting topic",
                            "nsfw": true,
                            "last_message_id":"6969",
                            "bitrate":420,
                            "parent_id": "5555"
                         }
                     }
                     """;

        var gateway_packet =
            JsonSerializer.Deserialize(src, SourceGenerationContext.Default.GatewayPacket);

        Assert.IsType<ChannelCreatePacket>(gateway_packet);
        
        Assert.True(gateway_packet is ChannelCreatePacket
        {
            Op: GatewayPacket.Opcode.Dispatch,
            Event: "CHANNEL_CREATE",
            Sequence: 1,
            Data:
            {
                Id: 922243411795390570,
                Name: "voice csennel",
                GuildId: 5678,
                Type: 2,
                Position: 3,
                Topic: "A very interesting topic",
                Nsfw: true,
                Bitrate: 420,
                ParentId: 5555,
                LastMessageId: 6969
            }
        });

    }

    [Fact]
    public void ChannelUpdateDeserialize()
    {
        string src = """
                     {
                         "op":0,
                         "t":"CHANNEL_UPDATE",
                         "s":1,
                         "d":{
                            "id": "922243411795390570",
                            "type": 2,
                            "guild_id": "5678",
                            "position": 3,
                            "name": "voice csennel",
                            "topic": "A very interesting topic",
                            "nsfw": true,
                            "last_message_id":"6969",
                            "bitrate":420,
                            "parent_id": "5555"
                         }
                     }
                     """;

        var gateway_packet =
            JsonSerializer.Deserialize(src, SourceGenerationContext.Default.GatewayPacket);

        Assert.IsType<ChannelUpdatePacket>(gateway_packet);
        
        Assert.True(gateway_packet is ChannelUpdatePacket
        {
            Op: GatewayPacket.Opcode.Dispatch,
            Event: "CHANNEL_UPDATE",
            Sequence: 1,
            Data:
            {
                Id: 922243411795390570,
                Name: "voice csennel",
                GuildId: 5678,
                Type: 2,
                Position: 3,
                Topic: "A very interesting topic",
                Nsfw: true,
                Bitrate: 420,
                ParentId: 5555,
                LastMessageId: 6969
            }
        });
    }
}