public void AddAttributesCallback_Ok()
    {
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData);

        Assert.NotEmpty(context.GetItems());
    }
    public void AddAttribute_Null()
    {
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData);

        context.AddAttribute(nameof(Foo.Name), typeof(DisplayAttribute), Type.EmptyTypes, Array.Empty <object>(), null, null);
    }
    public void OnGetSelectedRows_Ok()
    {
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData);
        var items     = context.GetItems().Take(1);

        context.OnGetSelectedRows = () => items;
        Assert.Equal(items, context.OnGetSelectedRows());
    }
    public void GetShownColumns_Ok()
    {
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData, AddAttributesCallback(localizer),
                                                    invisibleColumns: new string[] { nameof(Foo.DateTime) },
                                                    shownColumns: new string[] { nameof(Foo.Name) },
                                                    hiddenColumns: new string[] { nameof(Foo.Count) });

        Assert.Equal(4, context.GetColumns().Count());
    }
    public async Task OnValueChanged_Ok()
    {
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData);
        var item      = context.GetItems().First();

        item.SetValue(nameof(Foo.Name), "test-name");
        await context.SetValue(item);

        Assert.Equal("test-name", fooData.Rows[0].ItemArray[1]?.ToString());
        Assert.Equal("test-name", item.GetValue(nameof(Foo.Name)));

        // not exist
        item.DynamicObjectPrimaryKey = Guid.NewGuid();
        await context.SetValue(item);
    }
    public async Task DeleteAsync_Ok()
    {
        var deleted   = false;
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData)
        {
            OnDeleteAsync = foos =>
            {
                deleted = true;
                return(Task.FromResult(true));
            }
        };
        var items = context.GetItems();
        await context.DeleteAsync(items);

        Assert.True(deleted);
    }
    public async Task AddAsync_Ok()
    {
        var added     = false;
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData)
        {
            OnAddAsync = foos =>
            {
                added = true;
                return(Task.CompletedTask);
            }
        };
        var items = context.GetItems();
        await context.AddAsync(items);

        Assert.True(added);
    }
    public async Task DeleteAsync_Null()
    {
        var actual    = "";
        var deleted   = false;
        var added     = false;
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData)
        {
            OnChanged = args =>
            {
                deleted = args.ChangedType == DynamicItemChangedType.Delete;
                added   = args.ChangedType == DynamicItemChangedType.Add;
                actual  = args.Items.First().DynamicObjectPrimaryKey.ToString();
                return(Task.CompletedTask);
            }
        };
        var item     = context.GetItems().ToList().Take(1);
        var expected = item.First().DynamicObjectPrimaryKey.ToString();
        await context.DeleteAsync(item);

        Assert.Equal(expected, actual);
        Assert.True(deleted);
        Assert.Equal(3, context.GetItems().Count());

        // add
        await context.AddAsync(item);

        Assert.True(added);
        Assert.Equal(4, context.GetItems().Count());

        // add empty
        await context.AddAsync(Enumerable.Empty <IDynamicObject>());

        // 在选中行位置插入
        await context.AddAsync(context.GetItems().Take(2));
    }
    public async Task DataTableDynamicContext_Ok()
    {
        var added     = false;
        var deleted   = false;
        var localizer = Context.Services.GetRequiredService <IStringLocalizer <Foo> >();
        var fooData   = GenerateDataTable(localizer);
        var context   = new DataTableDynamicContext(fooData, AddAttributesCallback(localizer))
        {
            OnAddAsync = foos =>
            {
                added = true;
                return(Task.CompletedTask);
            },
            OnDeleteAsync = foos =>
            {
                deleted = true;
                return(Task.FromResult(true));
            }
        };

        var cols = context.GetColumns();

        Assert.NotEmpty(cols);

        var items = context.GetItems();

        Assert.NotEmpty(items);

        await context.OnAddAsync(new IDynamicObject[] { Utility.Clone(items.First()) });

        Assert.True(added);

        await context.OnDeleteAsync(items);

        Assert.True(deleted);
    }