found a bug on propertypaths on IDictionary<,> where Dictionary<,> worked fine

Author: Mpdreamz

src/Nest/Resolvers/PropertyNameResolver.cs

@@ -142,7 +142,13 @@ protected override Expression VisitMethodCall(MethodCallExpression m, Stack<stri
 			}
 			else if (m.Method.Name == "get_Item" && m.Arguments.Any())
 			{
-				if (!typeof(IDictionary).IsAssignableFrom(m.Object.Type))
+				var t = m.Object.Type;
+				var isDict = 
+					typeof(IDictionary).IsAssignableFrom(t)
+					|| typeof(IDictionary<,>).IsAssignableFrom(t)
+					|| (t.IsGenericType && t.GetGenericTypeDefinition() == typeof (IDictionary<,>));
+
+				if (!isDict)
 				{
 					return base.VisitMethodCall(m, stack, properties);
 				}

src/Tests/Nest.Tests.Unit/Internals/Inferno/PropertyVisitorTests.cs

@@ -1,29 +1,172 @@
-using NUnit.Framework;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using FluentAssertions;
+using Nest.Resolvers;
+using NUnit.Framework;
 using Nest.Tests.MockData.Domain;
 
 namespace Nest.Tests.Unit.Internals.Inferno
 {
 	[TestFixture]
 	public class PropertyVisitorTests
 	{
+		private class CustomDict : Dictionary<string, ElasticsearchProject> { }
+
+		private class DomainObject
+		{
+			public string Name { get; set; }
+			public IDictionary<string, ElasticsearchProject> Dictionary { get; set; }
+			public CustomDict CustomDict { get; set; }
+			public IList<ElasticsearchProject> Collection { get; set; }
+
+		}
+
+		private readonly ElasticInferrer _infer;
+		private readonly string _variable = "vari";
+
+		public PropertyVisitorTests()
+		{
+			_infer = TestElasticClient.Client.Infer;
+		}
+
+		private string P(Expression<Func<DomainObject, object>> path)
+		{
+			return this._infer.PropertyPath(Property.Path(path));
+		}
+
+		[Test]
+		public void SimpleProperty()
+		{
+			P(p => p.Name).Should().Be("name");
+		}
+
+		[Test]
+		public void SuffixOnPropery()
+		{
+			P(p => p.Name.Suffix("sort")).Should().Be("name.sort");
+		}
+
+		[Test]
+		public void IndexOnCollection()
+		{
+			P(p => p.Collection[0]).Should().Be("collection");
+		}
+
+		[Test]
+		public void IndexOnCollectionProperty()
+		{
+			P(p => p.Collection[0].Name).Should().Be("collection.name");
+		}
+
+		[Test]
+		public void FirstOnCollection()
+		{
+			P(p => p.Collection.First()).Should().Be("collection");
+		}
+
+		[Test]
+		public void FirstOnCollectionProperty()
+		{
+			P(p => p.Collection.First().Name).Should().Be("collection.name");
+		}
+
+		[Test]
+		public void Dictionary()
+		{
+			P(p => p.Dictionary["hardcoded"]).Should().Be("dictionary.hardcoded");
+		}
+
+		[Test]
+		public void DictionaryPropery()
+		{
+			P(p => p.Dictionary["hardcoded"].Name).Should().Be("dictionary.hardcoded.name");
+		}
+		
+		//Test variables
+		[Test]
+		public void DictionaryVariableKey()
+		{
+			P(p => p.Dictionary[_variable]).Should().Be("dictionary.vari");
+		}
+
+		[Test]
+		public void DictionaryVariableKeyProperty()
+		{
+			P(p => p.Dictionary[_variable].Name).Should().Be("dictionary.vari.name");
+		}
+
+		[Test]
+		public void CustomDictionary()
+		{
+			P(p => p.CustomDict["hardcoded"]).Should().Be("customDict.hardcoded");
+		}
+
+		[Test]
+		public void CustomDictionaryPropery()
+		{
+			P(p => p.CustomDict["hardcoded"].Name).Should().Be("customDict.hardcoded.name");
+		}
+		
+		//Test variables
+
+		[Test]
+		public void CustomDictionaryVariableKey()
+		{
+			P(p => p.CustomDict[_variable]).Should().Be("customDict.vari");
+		}
+
+		[Test]
+		public void CustomDictionaryVariableKeyProperty()
+		{
+			P(p => p.CustomDict[_variable].Name).Should().Be("customDict.vari.name");
+		}
+
+		//Test suffixes
+		[Test]
+		public void PropertySuffix()
+		{
+			P(p => p.Name.Suffix("suffix")).Should().Be("name.suffix");
+		}
+
+		[Test]
+		public void DictionarySuffix()
+		{
+			P(p => p.Dictionary["hardcoded"].Suffix("suffix")).Should().Be("dictionary.hardcoded.suffix");
+		}
+
+		[Test]
+		public void FirstOnCollectionSuffix()
+		{
+			P(p => p.Collection.First().Suffix("suffix")).Should().Be("collection.suffix");
+		}
+
 		[Test]
-		public void SuffixMakesItIntoPropertyName()
+		public void IndexOnCollectionSuffix()
 		{
-			var s = new SearchDescriptor<ElasticsearchProject>()
-			  .From(0)
-			  .Size(10)
-			  .Query(q => q.Term(f => f.Name.Suffix("sort"), "value"));
-			var json = TestElasticClient.Serialize(s);
-			var expected = @"{ from: 0, size: 10,
-			query: {
-		  term: {
-			""name.sort"": {
-			  value: ""value""
-			}
-		  }
+			P(p => p.Collection[0].Suffix("suffix")).Should().Be("collection.suffix");
 		}
-	  }";
-			Assert.True(json.JsonEquals(expected), json);
+
+		[Test]
+		public void CollectionSuffix()
+		{
+			P(p => p.Collection.Suffix("suffix")).Should().Be("collection.suffix");
 		}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 	}
 }