new test

import pytest

import os

import stat

from harness.logger import logger

def test_inline_append(gkfs_daemon, gkfs_client):

    """Test inline data append operations"""

    file = gkfs_daemon.mountdir / "file_inline_append"

    # Open file

    ret = gkfs_client.open(file,

                           os.O_CREAT | os.O_WRONLY,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    # Write initial data (inline)

    buf1 = b'A' * 100

    ret = gkfs_client.write(file, buf1, len(buf1))

    assert ret.retval == len(buf1)

    # Close and reopen for append

    gkfs_client.close(file) # Assuming close exists, or just open new fd

    # Actually gkfs_client.open returns an fd but the harness wrapper might abstract it.

    # Looking at test_write_operations.py, it just calls open again.

    ret = gkfs_client.open(file,

                           os.O_WRONLY | os.O_APPEND,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    # Append data (inline)

    buf2 = b'B' * 100

    ret = gkfs_client.write(file, buf2, len(buf2)) # write with O_APPEND implies append

    assert ret.retval == len(buf2)

    # Verify size

    ret = gkfs_client.stat(file)

    assert ret.retval == 0

    assert ret.statbuf.st_size == 200

    # Verify content

    ret = gkfs_client.open(file,

                           os.O_RDONLY,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    ret = gkfs_client.read(file, 200)

    assert ret.retval == 200

    assert ret.buf == buf1 + buf2

def test_inline_pwrite(gkfs_daemon, gkfs_client):

    """Test inline data overwrite using pwrite"""

    file = gkfs_daemon.mountdir / "file_inline_pwrite"

    ret = gkfs_client.open(file,

                           os.O_CREAT | os.O_WRONLY,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    # Write initial data

    buf1 = b'A' * 100

    ret = gkfs_client.write(file, buf1, len(buf1))

    assert ret.retval == len(buf1)

    # Overwrite middle part

    buf2 = b'B' * 50

    ret = gkfs_client.pwrite(file, buf2, len(buf2), 25)

    assert ret.retval == len(buf2)

    # Verify size (should be same)

    ret = gkfs_client.stat(file)

    assert ret.retval == 0

    assert ret.statbuf.st_size == 100

    # Verify content

    expected = b'A' * 25 + b'B' * 50 + b'A' * 25

    ret = gkfs_client.open(file,

                           os.O_RDONLY,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    ret = gkfs_client.read(file, 100)

    assert ret.retval == 100

    assert ret.buf == expected

def test_inline_overflow_append(gkfs_daemon, gkfs_client):

    """Test appending data that overflows inline limit (migration to chunks)"""

    file = gkfs_daemon.mountdir / "file_inline_overflow"

    ret = gkfs_client.open(file,

                           os.O_CREAT | os.O_WRONLY,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    # Write almost full inline data

    buf1 = b'A' * 4000

    ret = gkfs_client.write(file, buf1, len(buf1))

    assert ret.retval == len(buf1)

    # Reopen for append

    ret = gkfs_client.open(file,

                           os.O_WRONLY | os.O_APPEND,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    # Append enough to overflow 4096

    buf2 = b'B' * 200

    ret = gkfs_client.write(file, buf2, len(buf2))

    assert ret.retval == len(buf2)

    # Verify size

    ret = gkfs_client.stat(file)

    assert ret.retval == 0

    assert ret.statbuf.st_size == 4200

    # Verify content

    ret = gkfs_client.open(file,

                           os.O_RDONLY,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    ret = gkfs_client.read(file, 4200)

    assert ret.retval == 4200

    assert ret.buf == buf1 + buf2

def test_inline_overflow_pwrite(gkfs_daemon, gkfs_client):

    """Test pwrite that overflows inline limit (migration to chunks)"""

    file = gkfs_daemon.mountdir / "file_inline_overflow_pwrite"

    ret = gkfs_client.open(file,

                           os.O_CREAT | os.O_WRONLY,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    # Write small inline data

    buf1 = b'A' * 100

    ret = gkfs_client.write(file, buf1, len(buf1))

    assert ret.retval == len(buf1)

    # Pwrite far beyond inline limit (creating hole)

    buf2 = b'B' * 100

    offset = 5000

    ret = gkfs_client.pwrite(file, buf2, len(buf2), offset)

    assert ret.retval == len(buf2)

    # Verify size

    ret = gkfs_client.stat(file)

    assert ret.retval == 0

    assert ret.statbuf.st_size == offset + len(buf2)

    # Verify content

    ret = gkfs_client.open(file,

                           os.O_RDONLY,

                           stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)

    assert ret.retval != -1

    # Read hole + data

    # We expect A*100 + zeros + B*100

    # Total size = 5100

    ret = gkfs_client.read(file, 5100)

    assert ret.retval == 5100

    read_buf = ret.buf

    assert read_buf[0:100] == buf1

    assert read_buf[100:offset] == b'\x00' * (offset - 100)

    assert read_buf[offset:offset+100] == buf2