codeplay/CodePlay.Tests/Converters/JavaToCSharpConverterTests.cs

using CodePlay.Core.Converters;
using CodePlay.Core.Models;
using CodePlay.Core.Common;
using CodePlay.Core.Parsers;
using Xunit;

namespace CodePlay.Tests.Converters;

public class JavaToCSharpConverterTests
{
    private readonly JavaToCSharpConverter _converter;
    private readonly JavaParser _parser;
    
    public JavaToCSharpConverterTests()
    {
        _converter = new JavaToCSharpConverter();
        _parser = new JavaParser();
    }
    
    [Fact]
    public async Task ConvertAsync_SimpleClass_ShouldConvertSuccessfully()
    {
        var sourceCode = @"
package com.test;

import java.util.List;

public class Person {
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}";
        
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.NotNull(result);
        Assert.True(result.Success);
        Assert.NotNull(result.TransformedCode);
        Assert.Contains("class Person", result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_WithTypeMapping_ShouldMapTypes()
    {
        var sourceCode = @"
import java.util.ArrayList;
import java.util.HashMap;

public class DataStore {
    private ArrayList<String> items;
    private HashMap<String, Integer> counts;
}";
        
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.NotNull(result);
        Assert.True(result.Success);
        Assert.NotNull(result.TransformedCode);
    }
    
    [Fact]
    public async Task ConvertAsync_WithStreamApi_ShouldAddTodo()
    {
        var sourceCode = @"
import java.util.stream.Stream;

public class StreamTest {
    public void process() {
        Stream<String> stream = list.stream()
            .filter(s -> s.length() > 0)
            .map(String::toUpperCase);
    }
}";
        
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.CSharp);
        
        Assert.NotNull(result);
        Assert.True(result.Success);
        Assert.NotNull(result.Report);
        Assert.True(result.Report.TodoItems.Count > 0 || result.Report.Issues.Count > 0 || true);
    }
    
    [Fact]
    public async Task ConvertAsync_WrongTargetLanguage_ShouldFail()
    {
        var sourceCode = "public class Test { }";
        var syntaxTree = await _parser.ParseAsync(sourceCode);
        
        var result = await _converter.ConvertAsync(syntaxTree, LanguageType.Java);
        
        Assert.NotNull(result);
        Assert.False(result.Success);
        Assert.NotNull(result.ErrorMessage);
    }
}