WebGridTest.cs

// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Web.TestUtil;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.Test
{
    public class WebGridTest
    {
        [Fact]
        public void AjaxCheckedOnlyOnce()
        {
            var grid = new WebGrid(GetContext(), ajaxUpdateContainerId: "grid")
                .Bind(new[] { new { First = "First", Second = "Second" } });
            string html = grid.Table().ToString();
            Assert.Contains("<script", html);
            html = grid.Table().ToString();
            Assert.DoesNotContain("<script", html);
            html = grid.Pager().ToString();
            Assert.DoesNotContain("<script", html);
        }

        [Fact]
        public void AjaxCallbackIgnoredIfAjaxUpdateContainerIdIsNotSet()
        {
            var grid = new WebGrid(GetContext(), ajaxUpdateCallback: "myCallback")
                .Bind(new[] { new { First = "First", Second = "Second" } });
            string html = grid.Table().ToString();
            Assert.DoesNotContain("<script", html);
            Assert.DoesNotContain("myCallback", html);
        }

        [Fact]
        public void ColumnNameDefaultsExcludesIndexedProperties()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { "First", "Second" });
            Assert.Single(grid.ColumnNames);
            Assert.Contains("Length", grid.ColumnNames);
        }

        [Fact]
        public void ColumnNameDefaultsForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(new { First = "First", Second = "Second" }));
            Assert.Equal(2, grid.ColumnNames.Count());
            Assert.Contains("First", grid.ColumnNames);
            Assert.Contains("Second", grid.ColumnNames);
        }

        [Fact]
        public void ColumnNameDefaultsForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { First = "First", Second = "Second" } });
            Assert.Equal(2, grid.ColumnNames.Count());
            Assert.Contains("First", grid.ColumnNames);
            Assert.Contains("Second", grid.ColumnNames);
        }

        [Fact]
        public void ColumnNameDefaultsSupportsBindableTypes()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new
                {
                    DateTime = DateTime.MinValue,
                    DateTimeOffset = DateTimeOffset.MinValue,
                    Decimal = Decimal.MinValue,
                    Guid = Guid.Empty,
                    Int32 = 1,
                    NullableInt32 = (int?)1,
                    Object = new object(),
                    Projection = new { Foo = "Bar" },
                    TimeSpan = TimeSpan.MinValue
                }
            });
            Assert.Equal(7, grid.ColumnNames.Count());
            Assert.Contains("DateTime", grid.ColumnNames);
            Assert.Contains("DateTimeOffset", grid.ColumnNames);
            Assert.Contains("Decimal", grid.ColumnNames);
            Assert.Contains("Guid", grid.ColumnNames);
            Assert.Contains("Int32", grid.ColumnNames);
            Assert.Contains("NullableInt32", grid.ColumnNames);
            Assert.Contains("TimeSpan", grid.ColumnNames);
            Assert.DoesNotContain("Object", grid.ColumnNames);
            Assert.DoesNotContain("Projection", grid.ColumnNames);
        }

        [Fact]
        public void ColumnsIsNoOp()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { First = "First", Second = "Second" }
            });
            var columns = new[]
            {
                grid.Column("First"), grid.Column("Second")
            };
            Assert.Equal(columns, grid.Columns(columns));
        }

        [Fact]
        public void ColumnThrowsIfColumnNameIsEmptyAndNoFormat()
        {
            var grid = new WebGrid(GetContext()).Bind(new object[0]);
            Assert.ThrowsArgument(() => { grid.Column(columnName: String.Empty, format: null); }, "columnName", "The column name cannot be null or an empty string unless a custom format is specified.");
        }

        [Fact]
        public void ColumnThrowsIfColumnNameIsNullAndNoFormat()
        {
            var grid = new WebGrid(GetContext()).Bind(new object[0]);
            Assert.ThrowsArgument(() => { grid.Column(columnName: null, format: null); }, "columnName", "The column name cannot be null or an empty string unless a custom format is specified.");
        }

        [Fact]
        public void BindThrowsIfSourceIsNull()
        {
            Assert.ThrowsArgumentNull(() => { new WebGrid(GetContext()).Bind(null); }, "source");
        }

        [Fact]
        public void ConstructorThrowsIfRowsPerPageIsLessThanOne()
        {
            Assert.ThrowsArgumentOutOfRange(() => { new WebGrid(GetContext(), rowsPerPage: 0); }, "rowsPerPage", "Value must be greater than or equal to 1.", allowDerivedExceptions: true);
        }

        [Fact]
        public void GetHtmlDefaults()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            var html = grid.GetHtml();
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P2&amp;sortdir=ASC\">P2</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tfoot><tr>" +
                "<td colspan=\"3\">1 <a href=\"?page=2\">2</a> <a href=\"?page=2\">&gt;</a> </td>" +
                "</tr></tfoot>" +
                "<tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void WebGridProducesValidHtmlWhenSummaryIsSpecified()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            var caption = "WebGrid With Caption";
            var html = grid.GetHtml(caption: caption);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table>" +
                "<caption>" + caption + "</caption>" +
                "<thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P2&amp;sortdir=ASC\">P2</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tfoot><tr>" +
                "<td colspan=\"3\">1 <a href=\"?page=2\">2</a> <a href=\"?page=2\">&gt;</a> </td>" +
                "</tr></tfoot>" +
                "<tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void WebGridEncodesCaptionText()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            var caption = "WebGrid <> With Caption";
            var html = grid.GetHtml(caption: caption);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table>" +
                "<caption>WebGrid &lt;&gt; With Caption</caption>" +
                "<thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P2&amp;sortdir=ASC\">P2</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tfoot><tr>" +
                "<td colspan=\"3\">1 <a href=\"?page=2\">2</a> <a href=\"?page=2\">&gt;</a> </td>" +
                "</tr></tfoot>" +
                "<tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void GetHtmlWhenPageCountIsOne()
        {
            var grid = new WebGrid(GetContext())
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" }
                });
            var html = grid.GetHtml();
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P2&amp;sortdir=ASC\">P2</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void GetHtmlWhenPagingAndSortingAreDisabled()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, canPage: false, canSort: false)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            var html = grid.GetHtml();
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\">P1</th>" +
                "<th scope=\"col\">P2</th>" +
                "<th scope=\"col\">P3</th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>1</td><td>2</td><td>3</td></tr>" +
                "<tr><td>4</td><td>5</td><td>6</td></tr>" +
                "</tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void PageIndexCanBeReset()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageIndex);
            grid.PageIndex = 0;
            Assert.Equal(0, grid.PageIndex);
            // verify that selection link has updated page
            Assert.Equal("?page=1&row=1", grid.Rows.FirstOrDefault().GetSelectUrl());
        }

        [Fact]
        public void PageIndexCanBeResetToSameValue()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            grid.PageIndex = 0;
            Assert.Equal(0, grid.PageIndex);
        }

        [Fact]
        public void PageIndexDefaultsToZero()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(1, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void SetPageIndexThrowsExceptionWhenValueIsNegative()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.ThrowsArgumentOutOfRange(() => { grid.PageIndex = -1; }, "value", "Value must be between 0 and 1.");
        }

        [Fact]
        public void SetPageIndexThrowsExceptionWhenValueIsEqualToPageCount()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.ThrowsArgumentOutOfRange(() => { grid.PageIndex = grid.PageCount; }, "value", "Value must be between 0 and 1.");
        }

        [Fact]
        public void SetPageIndexThrowsExceptionWhenValueIsGreaterToPageCount()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.ThrowsArgumentOutOfRange(() => { grid.PageIndex = grid.PageCount + 1; }, "value", "Value must be between 0 and 1.");
        }

        [Fact]
        public void SetPageIndexThrowsExceptionWhenPagingIsDisabled()
        {
            var grid = new WebGrid(GetContext(), canPage: false)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Throws<NotSupportedException>(() => { grid.PageIndex = 1; }, "This operation is not supported when paging is disabled for the \"WebGrid\" object.");
        }

        [Fact]
        public void PageIndexResetsToLastPageWhenQueryStringValueGreaterThanPageCount()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(4, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void PageIndexResetWhenQueryStringValueIsInvalid()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "NotAnInt";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(1, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void PageIndexResetWhenQueryStringValueLessThanOne()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "0";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(1, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void PageIndexUsesCustomQueryString()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["g_pg"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1, fieldNamePrefix: "g_", pageFieldName: "pg")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(4, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void PageIndexUsesQueryString()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(4, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void GetPageCountWhenPagingIsTurnedOn()
        {
            var grid = new WebGrid(GetContext(), canPage: true, rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(2, grid.PageCount);
        }

        [Fact]
        public void GetPageIndexWhenPagingIsTurnedOn()
        {
            var grid = new WebGrid(GetContext(), canPage: true, rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" },
                    new { P1 = 4, P2 = '5', P3 = "6" },
                });
            grid.PageIndex = 1;
            Assert.Equal(1, grid.PageIndex);
            Assert.Equal(3, grid.PageCount);
            grid.PageIndex = 2;
            Assert.Equal(2, grid.PageIndex);
        }

        [Fact]
        public void GetPageCountWhenPagingIsTurnedOff()
        {
            var grid = new WebGrid(GetContext(), canPage: false, rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageCount);
        }

        [Fact]
        public void GetPageIndexWhenPagingIsTurnedOff()
        {
            var grid = new WebGrid(GetContext(), canPage: false, rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" },
                    new { P1 = 4, P2 = '5', P3 = "6" },
                });
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(1, grid.PageCount);
        }

        [Fact]
        public void PageUrlResetsSelection()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "0";
            queryString["row"] = "0";
            queryString["sort"] = "P1";
            queryString["sortdir"] = "DESC";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string url = grid.GetPageUrl(1);
            Assert.Equal("?page=2&sort=P1&sortdir=DESC", url);
        }

        [Fact]
        public void PageUrlResetsSelectionForAjax()
        {
            string expected40 = "$(&quot;#grid-container&quot;).swhgLoad(&quot;?page=2&amp;sort=P1&amp;sortdir=DESC&quot;,&quot;#grid-container&quot;);";
            string expected45 = "$(&quot;#grid-container&quot;).swhgLoad(&quot;?page=2\\u0026sort=P1\\u0026sortdir=DESC&quot;,&quot;#grid-container&quot;);";
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "0";
            queryString["row"] = "0";
            queryString["sort"] = "P1";
            queryString["sortdir"] = "DESC";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1, ajaxUpdateContainerId: "grid-container")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string html = grid.GetContainerUpdateScript(grid.GetPageUrl(1)).ToString();

            // Assert
            Assert.Equal(RuntimeEnvironment.IsVersion45Installed ? expected45 : expected40, html);
        }

        [Fact]
        public void PageUrlResetsSelectionForAjaxWithCallback()
        {
            string expected40 = "$(&quot;#grid&quot;).swhgLoad(&quot;?page=2&amp;sort=P1&amp;sortdir=DESC&quot;,&quot;#grid&quot;,myCallback);";
            string expected45 = "$(&quot;#grid&quot;).swhgLoad(&quot;?page=2\\u0026sort=P1\\u0026sortdir=DESC&quot;,&quot;#grid&quot;,myCallback);";
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "0";
            queryString["row"] = "0";
            queryString["sort"] = "P1";
            queryString["sortdir"] = "DESC";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1, ajaxUpdateContainerId: "grid", ajaxUpdateCallback: "myCallback")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string html = grid.GetContainerUpdateScript(grid.GetPageUrl(1)).ToString();

            // Assert
            Assert.Equal(RuntimeEnvironment.IsVersion45Installed ? expected45 : expected40, html);
        }

        [Fact]
        public void PageUrlThrowsIfIndexGreaterThanOrEqualToPageCount()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { } });
            Assert.ThrowsArgumentOutOfRange(() => { grid.GetPageUrl(2); }, "pageIndex", "Value must be between 0 and 1.");
        }

        [Fact]
        public void PageUrlThrowsIfIndexLessThanZero()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { } });
            Assert.ThrowsArgumentOutOfRange(() => { grid.GetPageUrl(-1); }, "pageIndex", "Value must be between 0 and 1.");
        }

        [Fact]
        public void PageUrlThrowsIfPagingIsDisabled()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, canPage: false).Bind(new[] { new { }, new { } });
            Assert.Throws<NotSupportedException>(() => { grid.GetPageUrl(2); }, "This operation is not supported when paging is disabled for the \"WebGrid\" object.");
        }

        [Fact]
        public void PagerRenderingDefaults()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { }, new { }, new { } });
            var html = grid.Pager();
            Assert.Equal(
                "1 " +
                "<a href=\"?page=2\">2</a> " +
                "<a href=\"?page=3\">3</a> " +
                "<a href=\"?page=4\">4</a> " +
                "<a href=\"?page=2\">&gt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnFirstShowingAll()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { }, new { }, new { } });
            var html = grid.Pager(WebGridPagerModes.All, numericLinksCount: 5);
            Assert.Equal(
                "1 " +
                "<a href=\"?page=2\">2</a> " +
                "<a href=\"?page=3\">3</a> " +
                "<a href=\"?page=4\">4</a> " +
                "<a href=\"?page=2\">&gt;</a> " +
                "<a href=\"?page=4\">&gt;&gt;</a>",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnNextToLastShowingAll()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.All, numericLinksCount: 4);
            Assert.Equal(
                "<a href=\"?page=1\">&lt;&lt;</a> " +
                "<a href=\"?page=2\">&lt;</a> " +
                "<a href=\"?page=1\">1</a> " +
                "<a href=\"?page=2\">2</a> " +
                "3 " +
                "<a href=\"?page=4\">4</a> " +
                "<a href=\"?page=4\">&gt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnMiddleShowingAll()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.All, numericLinksCount: 3);
            Assert.Equal(
                "<a href=\"?page=1\">&lt;&lt;</a> " +
                "<a href=\"?page=2\">&lt;</a> " +
                "<a href=\"?page=2\">2</a> " +
                "3 " +
                "<a href=\"?page=4\">4</a> " +
                "<a href=\"?page=4\">&gt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnSecondHidingFirstLast()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.NextPrevious | WebGridPagerModes.Numeric, numericLinksCount: 2);
            Assert.Equal(
                "<a href=\"?page=1\">&lt;</a> " +
                "2 " +
                "<a href=\"?page=3\">3</a> " +
                "<a href=\"?page=3\">&gt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnLastHidingFirstLast()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "4";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.NextPrevious | WebGridPagerModes.Numeric, numericLinksCount: 1);
            Assert.Equal(
                "<a href=\"?page=3\">&lt;</a> " +
                "4 ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnMiddleHidingNextPrevious()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.FirstLast | WebGridPagerModes.Numeric, numericLinksCount: 0);
            Assert.Equal(
                "<a href=\"?page=1\">&lt;&lt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnMiddleWithLinksCountGreaterThanPageCount()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.Numeric, numericLinksCount: 6);
            Assert.Equal(
                "<a href=\"?page=1\">1</a> " +
                "<a href=\"?page=2\">2</a> " +
                "3 " +
                "<a href=\"?page=4\">4</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingHidingAll()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 2).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.Numeric, numericLinksCount: 0);
            Assert.Equal("", html.ToString());
        }

        [Fact]
        public void PagerRenderingTextOverrides()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.FirstLast | WebGridPagerModes.NextPrevious,
                                  firstText: "first", previousText: "previous", nextText: "next", lastText: "last");
            Assert.Equal(
                "<a href=\"?page=1\">first</a> " +
                "<a href=\"?page=2\">previous</a> " +
                "<a href=\"?page=4\">next</a> " +
                "<a href=\"?page=5\">last</a>",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerThrowsIfTextSetAndModeNotEnabled()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { } });
            Assert.ThrowsArgument(() => { grid.Pager(firstText: "first"); }, "firstText", "To use this argument, pager mode \"FirstLast\" must be enabled.");
            Assert.ThrowsArgument(() => { grid.Pager(mode: WebGridPagerModes.Numeric, previousText: "previous"); }, "previousText", "To use this argument, pager mode \"NextPrevious\" must be enabled.");
            Assert.ThrowsArgument(() => { grid.Pager(mode: WebGridPagerModes.Numeric, nextText: "next"); }, "nextText", "To use this argument, pager mode \"NextPrevious\" must be enabled.");
            Assert.ThrowsArgument(() => { grid.Pager(lastText: "last"); }, "lastText", "To use this argument, pager mode \"FirstLast\" must be enabled.");
        }

        [Fact]
        public void PagerThrowsIfNumericLinkCountIsLessThanZero()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { } });
            Assert.ThrowsArgumentOutOfRange(() => { grid.Pager(numericLinksCount: -1); }, "numericLinksCount", "Value must be greater than or equal to 0.");
        }

        [Fact]
        public void PagerThrowsIfPagingIsDisabled()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, canPage: false).Bind(new[] { new { }, new { } });
            Assert.Throws<NotSupportedException>(() => { grid.Pager(); }, "This operation is not supported when paging is disabled for the \"WebGrid\" object.");
        }

        [Fact]
        public void PagerWithAjax()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, ajaxUpdateContainerId: "grid")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string html = grid.Pager().ToString();
            Assert.Contains("<script", html);
        }

        [Fact]
        public void PagerWithAjaxAndCallback()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, ajaxUpdateContainerId: "grid", ajaxUpdateCallback: "myCallback")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string html = grid.Pager().ToString();
            Assert.Contains("<script", html);
            Assert.Contains("data-swhgcallback=\"myCallback\"", html);
        }

        [Fact]
        public void PropertySettersDoNotThrowBeforePagingAndSorting()
        {
            // test with selection because SelectedIndex getter used to do range checking that caused paging and sorting
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "1";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 2).Bind(new[]
            {
                new { P1 = 1 }, new { P1 = 2 }, new { P1 = 3 }
            });

            // invoke other WebGrid properties to ensure they don't cause sorting and paging
            foreach (var prop in typeof(WebGrid).GetProperties())
            {
                // exceptions: these do cause sorting and paging
                if (prop.Name.Equals("Rows") || prop.Name.Equals("SelectedRow") || prop.Name.Equals("ElementType"))
                {
                    continue;
                }
                prop.GetValue(grid, null);
            }

            grid.PageIndex = 1;
            grid.SelectedIndex = 0;
            grid.SortColumn = "P1";
            grid.SortDirection = SortDirection.Descending;
        }

        [Fact]
        public void PropertySettersDoNotThrowAfterPagingAndSortingIfValuesHaveNotChanged()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 2).Bind(new[]
            {
                new { P1 = 1 }, new { P1 = 2 }, new { P1 = 3 }
            });
            // calling Rows will sort and page the data
            Assert.Equal(2, grid.Rows.Count());

            grid.PageIndex = 0;
            grid.SelectedIndex = -1;
            grid.SortColumn = String.Empty;
            grid.SortDirection = SortDirection.Ascending;
        }

        [Fact]
        public void PropertySettersThrowAfterPagingAndSorting()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 2).Bind(new[]
            {
                new { P1 = 1 }, new { P1 = 2 }, new { P1 = 3 }
            });
            // calling Rows will sort and page the data
            Assert.Equal(2, grid.Rows.Count());

            var message = "This property cannot be set after the \"WebGrid\" object has been sorted or paged. Make sure that this property is set prior to invoking the \"Rows\" property directly or indirectly through other methods such as \"GetHtml\", \"Pager\", \"Table\", etc.";
            Assert.Throws<InvalidOperationException>(() => { grid.PageIndex = 1; }, message);
            Assert.Throws<InvalidOperationException>(() => { grid.SelectedIndex = 0; }, message);
            Assert.Throws<InvalidOperationException>(() => { grid.SortColumn = "P1"; }, message);
            Assert.Throws<InvalidOperationException>(() => { grid.SortDirection = SortDirection.Descending; }, message);
        }

        [Fact]
        public void RowColumnsAreDynamicMembersForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(
                new { P1 = 1, P2 = '2', P3 = "3" }
                                                          ));
            dynamic row = grid.Rows.First();
            Assert.Equal(1, row.P1);
            Assert.Equal('2', row.P2);
            Assert.Equal("3", row.P3);
        }

        [Fact]
        public void RowColumnsAreDynamicMembersForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            dynamic row = grid.Rows.First();
            Assert.Equal(1, row.P1);
            Assert.Equal('2', row.P2);
            Assert.Equal("3", row.P3);
        }

        [Fact]
        public void RowExposesRowIndex()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { }, new { }, new { }
            });
            dynamic row = grid.Rows.First();
            Assert.Equal(0, row["ROW"]);
            row = grid.Rows.Skip(1).First();
            Assert.Equal(1, row.ROW);
            row = grid.Rows.Skip(2).First();
            Assert.Equal(2, row.ROW);
        }

        [Fact]
        public void RowExposesUnderlyingValue()
        {
            var sb = new StringBuilder("Foo");
            sb.Append("Bar");
            var grid = new WebGrid(GetContext()).Bind(new[] { sb });
            var row = grid.Rows.First();
            Assert.Equal(sb, row.Value);
            Assert.Equal("FooBar", row.ToString());
            Assert.Equal(grid, row.WebGrid);
        }

        [Fact]
        public void RowIndexerThrowsWhenColumnNameIsEmpty()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            Assert.ThrowsArgumentNullOrEmptyString(() => { var value = row[String.Empty]; }, "name");
        }

        [Fact]
        public void RowIndexerThrowsWhenColumnNameIsNull()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            Assert.ThrowsArgumentNullOrEmptyString(() => { var value = row[null]; }, "name");
        }

        [Fact] // todo - should throw ArgumentException?
        public void RowIndexerThrowsWhenColumnNotFound()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            Assert.Throws<InvalidOperationException>(() => { var value = row["NotAColumn"]; });
        }

        [Fact]
        public void RowIndexerThrowsWhenGreaterThanColumnCount()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            var row = grid.Rows.First();
            Assert.Throws<ArgumentOutOfRangeException>(() => { var value = row[4]; });
        }

        [Fact]
        public void RowIndexerThrowsWhenLessThanZero()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            Assert.Throws<ArgumentOutOfRangeException>(() => { var value = row[-1]; });
        }

        [Fact]
        public void RowIsEnumerableForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(
                new { P1 = 1, P2 = '2', P3 = "3" }
                                                          ));
            int i = 0;
            foreach (var col in (IEnumerable)grid.Rows.First())
            {
                i++;
            }
            Assert.Equal(3, i);
        }

        [Fact]
        public void RowIsEnumerableForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            int i = 0;
            foreach (var col in grid.Rows.First())
            {
                i++;
            }
            Assert.Equal(3, i);
        }

        [Fact]
        public void RowIsIndexableByColumnForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(
                new { P1 = 1, P2 = '2', P3 = "3" }
                                                          ));
            var row = grid.Rows.First();
            Assert.Equal(1, row["P1"]);
            Assert.Equal('2', row["P2"]);
            Assert.Equal("3", row["P3"]);
        }

        [Fact]
        public void RowIsIndexableByColumnForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]