SelectExtensionsTest.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.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Test;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class SelectExtensionsTest : IDisposable
    {
        private static readonly ViewDataDictionary<FooModel> _listBoxViewData = new ViewDataDictionary<FooModel> { { "foo", new[] { "Bravo" } } };
        private static readonly ViewDataDictionary<FooModel> _dropDownListViewData = new ViewDataDictionary<FooModel> { { "foo", "Bravo" } };
        private static readonly ViewDataDictionary<FooContainerModel> _nestedDropDownListViewData = new ViewDataDictionary<FooContainerModel> { { "foo", "Bravo" } };
        private static readonly ViewDataDictionary<NonIEnumerableModel> _nonIEnumerableViewData = new ViewDataDictionary<NonIEnumerableModel> { { "foo", 1 } };
        private static readonly ViewDataDictionary<EnumModel> _enumDropDownListViewData = new ViewDataDictionary<EnumModel>
        {
            { "WithDisplay", EnumWithDisplay.Two },
            { "WithDuplicates", EnumWithDuplicates.Second },
            { "WithFlags", EnumWithFlags.Second },
        };
        private static readonly SelectList _selectList = new SelectList(
            new[]
            {
                new { Text = "UFO", Value = "ufo", Category = "" }, /* Empty Group */
                new { Text = "Volvo", Value = "volvo", Category = "Swedish Cars" },
                new { Text = "Mercedes-Benz", Value = "mercedes-benz", Category = "German Cars" },
                new { Text = "Saab", Value = "saab", Category = "Swedish Cars" },
                new { Text = "Audi", Value = "audi", Category = "German Cars" },
                new { Text = "Other", Value = "other", Category = (string) null }, /* Another Empty Group */
                new { Text = "Unknown", Value = "unknown", Category = " " } /* Unnamed Group */
            }, "Value", "Text", "Category", (object) "audi");
        private static readonly MultiSelectList _multiSelectList = new MultiSelectList(
            new[]
            {
                new { Text = "UFO", Value = "ufo", Category = "" }, /* Empty Group */
                new { Text = "Volvo", Value = "volvo", Category = "Swedish Cars" },
                new { Text = "Mercedes-Benz", Value = "mercedes-benz", Category = "German Cars" },
                new { Text = "Saab", Value = "saab", Category = "Swedish Cars" },
                new { Text = "Audi", Value = "audi", Category = "German Cars" },
                new { Text = "Other", Value = "other", Category = (string) null }, /* Another Empty Group */
                new { Text = "Unknown", Value = "unknown", Category = " " } /* Unnamed Group */
            }, "Value", "Text", "Category", new[] { "audi", "volvo" });

        private static ViewDataDictionary GetViewDataWithSelectList()
        {
            ViewDataDictionary viewData = new ViewDataDictionary();
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");
            viewData["foo"] = selectList;
            viewData["foo.bar"] = selectList;
            return viewData;
        }

        private static List<SelectListItem> GroupedItems_WithDisabled
        {
            get
            {
                List<SelectListItem> items = new List<SelectListItem>();
                SelectListGroup disabledGroup = new SelectListGroup { Disabled = true, Name = "DisabledGroup" };
                items.Add(new SelectListItem() { Text = "Alice", Value = "a" });
                items.Add(new SelectListItem() { Text = "Bob", Value = "b", Group = disabledGroup });
                items.Add(new SelectListItem() { Text = "Charlie", Value = "c", Group = disabledGroup });
                items.Add(new SelectListItem() { Text = "David", Value = "d", Disabled = true });

                return items;
            }
        }

        // DropDownList

        private static List<SelectListItem> GroupedItems
        {
            get
            {
                List<SelectListItem> items = new List<SelectListItem>();
                SelectListGroup swedish = new SelectListGroup { Name = "Swedish Cars" };
                SelectListGroup german = new SelectListGroup { Name = "German Cars" };
                SelectListGroup unnamed = new SelectListGroup();
                items.Add(new SelectListItem() { Text = "other1", Value = "other1" });
                items.Add(new SelectListItem() { Text = "other2", Value = "other2" });
                items.Add(new SelectListItem() { Group = swedish, Text = "Volvo", Value = "volvo" });
                items.Add(new SelectListItem() { Text = "other3", Value = "other3" });
                items.Add(new SelectListItem() { Group = unnamed, Text = "other4", Value = "other4" });
                items.Add(new SelectListItem() { Group = unnamed, Text = "other5", Value = "other5" });
                items.Add(new SelectListItem() { Group = german, Text = "Mercedes-Benz", Value = "mercedes-benz" });
                items.Add(new SelectListItem() { Group = swedish, Text = "Saab", Value = "saab", Selected = true });
                items.Add(new SelectListItem() { Group = german, Text = "Audi", Value = "audi", Disabled = true });
                items.Add(new SelectListItem() { Text = "other6", Value = "other6" });

                return items;
            }
        }

        [Fact]
        void DropDownList_WithGroups()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedDropDownListHtml = @"<select id=""List"" name=""List""><option value=""other1"">other1</option>
<option value=""other2"">other2</option>
<optgroup label=""Swedish Cars"">
<option value=""volvo"">Volvo</option>
<option selected=""selected"" value=""saab"">Saab</option>
</optgroup>
<option value=""other3"">other3</option>
<optgroup>
<option value=""other4"">other4</option>
<option value=""other5"">other5</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option disabled=""disabled"" value=""audi"">Audi</option>
</optgroup>
<option value=""other6"">other6</option>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownList("List", GroupedItems);

            // Assert
            Assert.Equal(expectedDropDownListHtml, html.ToHtmlString());
        }

        [Fact]
        void DropDownList_WithGroups_WithDisabled()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedDropDownListHtml = @"<select id=""List"" name=""List""><option value=""a"">Alice</option>
<optgroup disabled=""disabled"" label=""DisabledGroup"">
<option value=""b"">Bob</option>
<option value=""c"">Charlie</option>
</optgroup>
<option disabled=""disabled"" value=""d"">David</option>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownList("List", GroupedItems_WithDisabled);

            // Assert
            Assert.Equal(expectedDropDownListHtml, html.ToHtmlString());
        }


        [Fact]
        void DropDownList_SelectList_WithGroups()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedDropDownListHtml = @"<select id=""List"" name=""List""><option value=""ufo"">UFO</option>
<optgroup label=""Swedish Cars"">
<option value=""volvo"">Volvo</option>
<option value=""saab"">Saab</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option selected=""selected"" value=""audi"">Audi</option>
</optgroup>
<option value=""other"">Other</option>
<optgroup label="" "">
<option value=""unknown"">Unknown</option>
</optgroup>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownList("List", _selectList);

            // Assert
            Assert.Equal(expectedDropDownListHtml, html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesExplicitValueIfNotProvidedInViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesExplicitValueIfNotProvidedInViewData_Unobtrusive()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select data-val=\"true\" data-val-type=\"error\" id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesViewDataDefaultValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(_dropDownListViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), "Charlie");

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesViewDataDefaultValueNoOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(_dropDownListViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), "Charlie");

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.DropDownList(String.Empty, (SelectList)null /* selectList */, (string)null /* optionLabel */); },
                "name");
        }

        [Fact]
        public void DropDownListWithErrors()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });
            ViewDataDictionary viewData = GetViewDataWithErrors();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" class=\"input-validation-error\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithErrorsAndCustomClass()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            ViewDataDictionary viewData = GetViewDataWithErrors();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, new { @class = "foo-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error foo-class\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithNullNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.DropDownList(null /* name */, (SelectList)null /* selectList */, (string)null /* optionLabel */); },
                "name");
        }

        [Fact]
        public void DropDownListWithNullSelectListUsesViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewData["foo"] = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionary()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            ViewDataDictionary viewData = new ViewDataDictionary();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryWithUnderscores()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            ViewDataDictionary viewData = new ViewDataDictionary();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndSelectList()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndSelectListNoOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryWithUnderscoresAndSelectListNoOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndEmptyOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, String.Empty /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option value=\"\"></option>" + Environment.NewLine
              + "<option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndTitle()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, "[Select Something]", HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option value=\"\">[Select Something]</option>" + Environment.NewLine
              + "<option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesViewDataSelectList()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetViewDataWithSelectList());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesModelState()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            ViewDataDictionary viewData = GetViewDataWithErrors();
            viewData["foo"] = selectList;
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesViewDataSelectListNoOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetViewDataWithSelectList());

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithDotReplacementForId()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetViewDataWithSelectList());

            // Act
            MvcHtmlString html = helper.DropDownList("foo.bar");

            // Assert
            Assert.Equal(
                "<select id=\"foo_bar\" name=\"foo.bar\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithIEnumerableSelectListItem()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", MultiSelectListTest.GetSampleIEnumerableObjects() } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithIEnumerableSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", "123456789" } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", MultiSelectListTest.GetSampleIEnumerableObjects());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithIEnumerableOfSelectListItemMatchesEnumName()
        {
            // Arrange
            ViewDataDictionary<EnumWithDisplay> vdd = new ViewDataDictionary<EnumWithDisplay>
            {
                { "foo", EnumWithDisplay.Three }
            };
            HtmlHelper<EnumWithDisplay> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html =
                helper.DropDownList("foo", GetSelectListWithNamedValuesForEnumWithDisplay(includeEmpty: false));

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\">" +
                "<option value=\"Zero\">Zero</option>" + Environment.NewLine +
                "<option value=\"One\">One</option>" + Environment.NewLine +
                "<option value=\"Two\">Two</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"Three\">Three</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithIEnumerableOfSelectListItemMatchesEnumValue()
        {
            // Arrange
            ViewDataDictionary<EnumWithDisplay> vdd = new ViewDataDictionary<EnumWithDisplay>
            {
                { "foo", EnumWithDisplay.Three }
            };
            HtmlHelper<EnumWithDisplay> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html =
                helper.DropDownList("foo", GetSelectListWithNumericValuesForEnumWithDisplay(includeEmpty: false));

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\">" +
                "<option value=\"0\">Zero</option>" + Environment.NewLine +
                "<option value=\"1\">One</option>" + Environment.NewLine +
                "<option value=\"2\">Two</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"3\">Three</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithListOfSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", "123456789" } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", MultiSelectListTest.GetSampleListObjects());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithListOfSelectListItem()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", MultiSelectListTest.GetSampleListObjects() } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithNullViewDataValueThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { helper.DropDownList("foo", (string)null /* optionLabel */); },
                "There is no ViewData item of type 'IEnumerable<SelectListItem>' that has the key 'foo'.");
        }

        [Fact]
        public void DropDownListWithWrongViewDataTypeValueThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary { { "foo", 123 } });

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { helper.DropDownList("foo", (string)null /* optionLabel */); },
                "The ViewData item that has the key 'foo' is of type 'System.Int32' but must be of type 'IEnumerable<SelectListItem>'.");
        }

        [Fact]
        public void DropDownListWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix_foo\" name=\"MyPrefix.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.DropDownList("", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix\" name=\"MyPrefix\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithPrefixAndNullSelectListUsesViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewData["foo"] = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"MyPrefix_foo\" name=\"MyPrefix.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_AddedHtmlAttributes(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result =
                helper.DropDownList(name: "name", selectList: selectList, htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<select attribute=\"" +
                    encodedText +
                    "\" id=\"name\" name=\"name\"><option>text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_Name(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result =
                helper.DropDownList(name: text, selectList: selectList, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"id\" name=\"" +
                    encodedText +
                    "\"><option>text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_OptGroupLabel(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Group = new SelectListGroup { Name = text, }, Text = "text", },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.DropDownList(name: "name", selectList: selectList).ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"name\" name=\"name\"><optgroup label=\"" +
                    encodedText +
                    "\">" +
                    Environment.NewLine +
                    "<option>text</option>" +
                    Environment.NewLine +
                    "</optgroup>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_HtmlEncodes_OptionLabel(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.DropDownList(name: "name", selectList: selectList, optionLabel: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"name\" name=\"name\"><option value=\"\">" +
                    encodedText +
                    "</option>" +
                    Environment.NewLine +
                    "<option>text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_Prefix(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", },
            };
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result =
                helper.DropDownList(name: String.Empty, selectList: selectList, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"id\" name=\"" +
                    encodedText +
                    "\"><option>text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_HtmlEncodes_Text(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = text, },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.DropDownList(name: "name", selectList: selectList).ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"name\" name=\"name\"><option>" +
                    encodedText +
                    "</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_Value(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", Value = text },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.DropDownList(name: "name", selectList: selectList).ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"name\" name=\"name\"><option value=\"" +
                    encodedText +
                    "\">text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        // DropDownListFor

        [Fact]
        void DropDownListFor_WithGroups()
        {
            // Arrange
            ViewDataDictionary<FooModel> dict = new ViewDataDictionary<FooModel>();
            dict.Add("foo", "volvo");
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(dict);
            const string expectedListBox = @"<select id=""foo"" name=""foo""><option value="""">Cars</option>
<option value=""other1"">other1</option>
<option value=""other2"">other2</option>
<optgroup label=""Swedish Cars"">
<option selected=""selected"" value=""volvo"">Volvo</option>
<option value=""saab"">Saab</option>
</optgroup>
<option value=""other3"">other3</option>
<optgroup>
<option value=""other4"">other4</option>
<option value=""other5"">other5</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option disabled=""disabled"" value=""audi"">Audi</option>
</optgroup>
<option value=""other6"">other6</option>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, GroupedItems, optionLabel: "Cars");

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());