merge

.gitignore

@@ -6,7 +6,7 @@
 *.user
 *.userosscache
 *.sln.docstates
-
+*.DotSettings
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
 

appveyor.yml

@@ -1,5 +1,11 @@
 version: 0.2.{build}
 configuration: Release
+notifications:
+- provider: Webhook
+  url: https://webhooks.gitter.im/e/cff271c9681834896234
+  on_build_success: true
+  on_build_failure: true
+  on_build_status_changed: true
 assembly_info:
   patch: true
   file: '**\AssemblyInfo.*'

src/Untappd.Net.UnitTests/Authentication/TestAuthenticationHelper.cs

@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using NUnit.Framework;
 using Untappd.Net.Authentication;
 using Untappd.Net.Client;
@@ -47,5 +43,22 @@ namespace Untappd.Net.UnitTests.Authentication
 
             AuthenticationHelper.TokenUrl(new UnAuthenticatedUntappdCredentials("d", "d"),  "ds", string.Empty);
         }
+
+        [Test]
+        public void TestTokenUrl()
+        {
+
+           var s = AuthenticationHelper.TokenUrl(new UnAuthenticatedUntappdCredentials("d", "d"), "ds", "code");
+           Assert.AreEqual(s, Constants.OAuthTokenEndPoint + "/?client_id=d&client_secret=d&response_type=code&redirect_url=ds&code=code");
+
+        }
+        [Test]
+        public void TestRedirectUrl()
+        {
+
+            var s = AuthenticationHelper.RedirectUserTo(new UnAuthenticatedUntappdCredentials("d", "d"), "ds");
+            Assert.AreEqual(s, Constants.BaseRequestString + "/?client_id=d&response_type=code&redirect_url=ds");
+
+        }
     }
 }

src/Untappd.Net.UnitTests/Request/TestRepository.cs

@@ -6,6 +6,7 @@ using RestSharp;
 using Untappd.Net.Client;
 using Untappd.Net.Request;
 using Untappd.Net.Responses.BeerInfo;
+using System.Threading.Tasks;
 
 namespace Untappd.Net.UnitTests.Request
 {
@@ -30,12 +31,29 @@ namespace Untappd.Net.UnitTests.Request
             client.Setup(a => a.Execute(It.IsAny<IRestRequest>())).Callback(() =>
             {
             }).Returns(response.Object);
+            client.Setup(a => a.ExecuteTaskAsync(It.IsAny<IRestRequest>())).Callback(() =>
+            {
+            }).Returns(Task.Run(()=> response.Object));
             var repository = new Repository(client.Object, request.Object);
            
             repository.Get<BeerInfo>(mockCreds.Object, "awesome", bodyParam);
             request.Verify(a => a.AddParameter("client_id", mockCreds.Object.ClientId));
             request.Verify(a => a.AddParameter("client_secret", mockCreds.Object.ClientSecret));
             request.Verify(a => a.AddParameter("key", "value"));
+            repository.GetAsync<BeerInfo>(mockCreds.Object, "awesome", bodyParam).Wait();
+            request.Verify(a => a.AddParameter("client_id", mockCreds.Object.ClientId));
+            request.Verify(a => a.AddParameter("client_secret", mockCreds.Object.ClientSecret));
+            request.Verify(a => a.AddParameter("key", "value"));
+
+            var mockAuthCreds = new Mock<IAuthenticatedUntappdCredentials>();
+            mockAuthCreds.Setup(a => a.AccessToken).Returns("accessToken");
+
+            repository.Get<BeerInfo>(mockAuthCreds.Object, "awesome", bodyParam);
+            request.Verify(a => a.AddParameter("key", "value"));
+            request.Verify(a => a.AddParameter("access_token", "accessToken"));
+            repository.GetAsync<BeerInfo>(mockAuthCreds.Object, "awesome", bodyParam).Wait();
+            request.Verify(a => a.AddParameter("key", "value"));
+            request.Verify(a => a.AddParameter("access_token", "accessToken"));
         }
 
         [Test]
@@ -45,5 +63,14 @@ namespace Untappd.Net.UnitTests.Request
             Assert.IsTrue(constructorTest.Client != null);
             Assert.IsTrue(constructorTest.Request != null);
         }
+        [Test]
+        public void ConfirmConfigureGetRequestClearsParams()
+        {
+            var constructorTest = new Repository();
+            constructorTest.Request.Parameters.Add(new Parameter(){Name = "param"});
+            Assert.IsTrue(constructorTest.Request.Parameters.Count > 0);
+            constructorTest.ConfigureGetRequest("endpoint");
+            Assert.IsTrue(constructorTest.Request.Parameters.Count == 0);
+        }
     }
 }

src/Untappd.Net.UnitTests/Responses/TestDeserializer.cs

@@ -1,21 +1,22 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
+using System.IO;
+using Newtonsoft.Json;
 using NUnit.Framework;
 using Untappd.Net.Client;
 using Untappd.Net.Request;
-using Newtonsoft.Json;
+using Untappd.Net.Responses.BeerInfo;
-using UserInfo = Untappd.Net.Responses.UserInfo;
+using Untappd.Net.Responses.BeerSearch;
-using ActivityFeed = Untappd.Net.Responses.Feeds.ActivityFeed;
+using Untappd.Net.Responses.BreweryInfo;
-using UserActivityFeed = Untappd.Net.Responses.Feeds.UserActivityFeed;
+using Untappd.Net.Responses.BrewerySearch;
-using UserBadges = Untappd.Net.Responses.UserBadges;
+using Untappd.Net.Responses.Feeds.ActivityFeed;
-using BeerInfo = Untappd.Net.Responses.BeerInfo;
+using Untappd.Net.Responses.Feeds.UserActivityFeed;
-using BeerSearch = Untappd.Net.Responses.BeerSearch;
+using Untappd.Net.Responses.UserBadges;
-using BreweryInfo = Untappd.Net.Responses.BreweryInfo;
+using Untappd.Net.Responses.UserFriends;
-using BrewerySearch = Untappd.Net.Responses.BrewerySearch;
+using Untappd.Net.Responses.UserInfo;
+using Untappd.Net.Responses.VenueInfo;
 using UserDistinctBeers = Untappd.Net.Responses.UserDistinctBeer;
-using UserFriends = Untappd.Net.Responses.UserFriends;
 using UserWishList = Untappd.Net.Responses.UserWishlist;
-using VenueInfo = Untappd.Net.Responses.VenueInfo;
+using System;
 
 namespace Untappd.Net.UnitTests
 {
@@ -38,92 +39,105 @@ namespace Untappd.Net.UnitTests
 
             var repo = new Repository();
             //var resp = repo.Get<ActivityFeed.ActivityFeed>(credentials);
-            var resp3 = repo.Get<BrewerySearch.BrewerySearch>(credentials, "", parameters);
+            var resp3 = repo.Get<BrewerySearch>(credentials, "", parameters);
-            var resp2 = repo.Get<UserActivityFeed.UserActivityFeed>(credentials);
+            var resp2 = repo.Get<UserActivityFeed>(credentials);
         }
 
         [Test]
         public void TestJsonDeserializeUserBadges()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "UserBadges.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "UserBadges.json"));
-            var jsonresult = JsonConvert.DeserializeObject<UserBadges.UserBadges>(json);
+            var jsonresult = JsonConvert.DeserializeObject<UserBadges>(json);
         }
 
         [Test]
         public void TestJsonDeserializerBeerInfo()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "BeerInfo.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "BeerInfo.json"));
-            var jsonresult = JsonConvert.DeserializeObject<BeerInfo.BeerInfo>(json);
+            var jsonresult = JsonConvert.DeserializeObject<BeerInfo>(json);
         }
 
         [Test]
         public void TestJsonDeserializerBeerSearch()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "BeerSearch.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "BeerSearch.json"));
-            var jsonresult = JsonConvert.DeserializeObject<BeerSearch.BeerSearch>(json);
+            var jsonresult = JsonConvert.DeserializeObject<BeerSearch>(json);
         }
 
         [Test]
         public void TestJsonDeserializerBreweryInfo()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "BreweryInfo.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "BreweryInfo.json"));
-            var jsonresult = JsonConvert.DeserializeObject<BreweryInfo.BreweryInfo>(json);
+            var jsonresult = JsonConvert.DeserializeObject<BreweryInfo>(json);
         }
 
         [Test]
         public void TestJsonDeserializerBrewerySearch()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "BrewerySearch.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "BrewerySearch.json"));
-            var jsonresult = JsonConvert.DeserializeObject<BrewerySearch.BrewerySearch>(json);
+            var jsonresult = JsonConvert.DeserializeObject<BrewerySearch>(json);
         }
 
         [Test]
         public void TestJsonDeserializerUserDistinctBeers()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "UserDistinctBeers.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "UserDistinctBeers.json"));
             var jsonresult = JsonConvert.DeserializeObject<UserDistinctBeers.UserDistinctBeers>(json);
         }
 
         [Test]
         public void TestJsonDeserializerUserFriends()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "UserFriends.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "UserFriends.json"));
-            var jsonresult = JsonConvert.DeserializeObject<UserFriends.UserFriends>(json);
+            var jsonresult = JsonConvert.DeserializeObject<UserFriends>(json);
         }
 
         [Test]
         public void TestJsonDeserializerUserInfo()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "UserInfo.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "UserInfo.json"));
-            var jsonresult = JsonConvert.DeserializeObject<UserInfo.UserInfo>(json);
+            var jsonresult = JsonConvert.DeserializeObject<UserInfo>(json);
         }
 
         [Test]
         public void TestJsonDeserializerUserWishList()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "UserWishList.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "UserWishList.json"));
             var jsonresult = JsonConvert.DeserializeObject<UserWishList.UserWishList>(json);
         }
 
         [Test]
         public void TestJsonDeserializerVenueInfo()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "VenueInfo.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "VenueInfo.json"));
-            var jsonresult = JsonConvert.DeserializeObject<VenueInfo.VenueInfo>(json);
+            var jsonresult = JsonConvert.DeserializeObject<VenueInfo>(json);
         }
 
         [Test]
         public void TestJsonDeserializerActivityFeed()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "ActivityFeed.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "ActivityFeed.json"));
-            var jsonresult = JsonConvert.DeserializeObject<ActivityFeed.ActivityFeed>(json);
+            var jsonresult = JsonConvert.DeserializeObject<ActivityFeed>(json);
         }
 
         [Test]
         public void TestJsonDeserializerUserActivityFeed()
         {
-            var json = System.IO.File.ReadAllText(string.Format(ResponsePath, "UserActivityFeed.json"));
+            var json = File.ReadAllText(string.Format(ResponsePath, "UserActivityFeed.json"));
-            var jsonresult = JsonConvert.DeserializeObject<UserActivityFeed.UserActivityFeed>(json);
+            var jsonresult = JsonConvert.DeserializeObject<UserActivityFeed>(json);
+        }
+
+        [Test]
+        [ExpectedException(typeof(NotImplementedException))]
+        public void testNotImplementedException()
+        {
+             new SingleObjectArrayConverter<UserActivityFeed>().WriteJson(null, null, null);
+        }
+
+        [Test]
+        public void testTypeValid()
+        {
+           Assert.IsTrue(new SingleObjectArrayConverter<UserActivityFeed>().CanConvert(typeof(UserActivityFeed)));
         }
     }
 }

src/Untappd.Net.UnitTests/Responses/TestResponseEndpoints.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Untappd.Net.Request;
+
+namespace Untappd.Net.UnitTests.Responses
+{
+    [TestFixture]
+    public class TestResponseEndpoints
+    {
+
+        /// <summary>
+        /// Run through all the endpoints to make sure they all atleast do not error out. 
+        /// This is so we can get a high code coverage, while also covering new types that get added.
+        /// </summary>
+        [Test]
+        public void RunAllEndpoints()
+        {
+
+            var objects = Assembly.GetAssembly(typeof (IRequest)).GetTypes().Where(myType => 
+                myType.IsClass 
+                && !myType.IsAbstract 
+                && myType.GetInterface("IRequest") != null).Select(type => (IRequest) Activator.CreateInstance(type)).ToList();
+            objects.ForEach(a=>Assert.IsNotNullOrEmpty(a.EndPoint("t")));
+        }
+        [Test]
+         public void RunAllEndpointsWithEmptyString()
+        {
+
+            var objects = Assembly.GetAssembly(typeof (IRequest)).GetTypes().Where(myType => 
+                myType.IsClass 
+                && !myType.IsAbstract 
+                && myType.GetInterface("IRequest") != null).Select(type => (IRequest) Activator.CreateInstance(type)).ToList();
+            objects.ForEach(a=>Assert.IsNotNullOrEmpty(a.EndPoint(string.Empty)));
+        }
+    }
+}

src/Untappd.Net.UnitTests/Untappd.Net.UnitTests.csproj

@@ -77,6 +77,7 @@
     <Compile Include="Exception\TestEndpointConfigurationException.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Request\TestRepository.cs" />
+    <Compile Include="Responses\TestResponseEndpoints.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Responses\Json\ActivityFeed.json" />

src/Untappd.Net/Authentication/AuthenticationHelper.cs

@@ -1,10 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Untappd.Net.Client;
-using Untappd.Net.Request;
 
 namespace Untappd.Net.Authentication
 {

src/Untappd.Net/Client/UnAuthenticatedUntappdCredentials.cs

@@ -1,6 +1,4 @@
-using System;
+namespace Untappd.Net.Client
-
-namespace Untappd.Net.Client
 {
     public class UnAuthenticatedUntappdCredentials : UntappdCredentials, IUnAuthenticatedUntappdCredentials
     {

src/Untappd.Net/Client/UntappdCredentials.cs

@@ -12,7 +12,7 @@ namespace Untappd.Net.Client
         /// </summary>
         /// <param name="clientId"></param>
         /// <param name="clientSecret"></param>
-        public UntappdCredentials(string clientId, string clientSecret)
+        protected UntappdCredentials(string clientId, string clientSecret)
         {
             if (string.IsNullOrWhiteSpace(clientId))
             {

src/Untappd.Net/Exception/EndpointConfigurationException.cs

@@ -1,5 +1,6 @@
 namespace Untappd.Net.Exception
 {
+    [System.Serializable]
     public class EndpointConfigurationException : BaseUntappdException
     {
         /// <summary>

src/Untappd.Net/Request/BasicRequest.cs

@@ -1,4 +1,5 @@
 using System;
+
 namespace Untappd.Net.Request
 {
     public abstract class BasicRequest

src/Untappd.Net/Request/IAuthenticatedRequest.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Untappd.Net.Request
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Untappd.Net.Request
 {
     public interface IAuthenticatedRequest : IRequest
     {

src/Untappd.Net/Request/IRequest.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Untappd.Net.Request
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Untappd.Net.Request
 {
     public interface IRequest
     {

src/Untappd.Net/Request/IUnAuthenticatedRequest.cs

@@ -1,10 +1,4 @@
-using System;
+namespace Untappd.Net.Request
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Untappd.Net.Request
 {
     public interface IUnAuthenticatedRequest : IRequest
     {

src/Untappd.Net/Request/Repository.cs

@@ -1,9 +1,8 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Newtonsoft.Json;
 using RestSharp;
 using Untappd.Net.Client;
+using System.Threading.Tasks;
 using System.Threading;
 
 namespace Untappd.Net.Request
@@ -25,15 +24,18 @@ namespace Untappd.Net.Request
             Request = request;
         }
 
-        private void ConfigureGetRequest(IRestRequest request, string endPoint, IDictionary<string, string> bodyParameters = null)
+        internal void ConfigureGetRequest(string endPoint, Method webMethod = Method.GET, IDictionary<string, string> bodyParameters = null)
         {
-            request.Resource = endPoint;
+            Request.Resource = endPoint;
-            request.Method = Method.GET;
+            Request.Method = webMethod;
-            if (request.Parameters != null) this.Request.Parameters.Clear();
+            if (Request.Parameters != null) Request.Parameters.Clear();
 
-            if (bodyParameters != null)
+            if (bodyParameters == null) return;
-                foreach (var param in bodyParameters)
+            foreach (var param in bodyParameters)
-                    request.AddParameter(param.Key, param.Value);
+            {
+                Request.AddParameter(param.Key, param.Value);
+            }
+               
         }
 
         /// <summary>
@@ -48,12 +50,28 @@ namespace Untappd.Net.Request
             where TResult : IUnAuthenticatedRequest,new()
         {
             var result = new TResult();
-            this.ConfigureGetRequest(this.Request, result.EndPoint(urlParameter), bodyParameters);
+            ConfigureGetRequest(result.EndPoint(urlParameter), Method.GET, bodyParameters);
-            
+            Request.AddParameter("client_id", credentials.ClientId);
-            this.Request.AddParameter("client_id", credentials.ClientId);
+            Request.AddParameter("client_secret", credentials.ClientSecret);
-            this.Request.AddParameter("client_secret", credentials.ClientSecret);
+            return DoRestRequest<TResult>();
+        }
 
-            return this.DoRestRequest<TResult>(this.Request);
+        /// <summary>
+        /// Get the things! Async!
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="credentials"></param>
+        /// <param name="urlParameter"></param>
+        /// <param name="bodyParameters"></param>
+        /// <returns></returns>
+        public Task<TResult> GetAsync<TResult>(IUnAuthenticatedUntappdCredentials credentials, string urlParameter, IDictionary<string, string> bodyParameters = null)
+           where TResult : IUnAuthenticatedRequest, new()
+        {
+            var result = new TResult();
+            ConfigureGetRequest(result.EndPoint(urlParameter), Method.GET, bodyParameters);
+            Request.AddParameter("client_id", credentials.ClientId);
+            Request.AddParameter("client_secret", credentials.ClientSecret);
+            return DoRestRequestAsync<TResult>();
         }
 
         /// <summary>
@@ -68,26 +86,38 @@ namespace Untappd.Net.Request
             where TResult : IAuthenticatedRequest, new()
         {
             var result = new TResult();
-            this.ConfigureGetRequest(this.Request, result.EndPoint(urlParameter), bodyParameters);
+            ConfigureGetRequest(result.EndPoint(urlParameter), Method.GET, bodyParameters);
-
+            Request.AddParameter("access_token", credentials.AccessToken);
-            this.Request.AddParameter("access_token", credentials.AccessToken);
+            return DoRestRequest<TResult>();
-
-            return this.DoRestRequest<TResult>(this.Request);
         }
 
-        private TResult DoRestRequest<TResult>(IRestRequest request)
+        /// <summary>
+        /// Get the things Authenticated! Async!!
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="credentials"></param>
+        /// <param name="urlParameter"></param>
+        /// <param name="bodyParameters"></param>
+        /// <returns></returns>
+        public Task<TResult> GetAsync<TResult>(IAuthenticatedUntappdCredentials credentials, string urlParameter = "", IDictionary<string, string> bodyParameters = null)
+           where TResult : IAuthenticatedRequest, new()
         {
-            var client = new RestClient(Constants.BaseRequestString);
+            var result = new TResult();
-            var resp = client.Execute(request);
+            ConfigureGetRequest(result.EndPoint(urlParameter), Method.GET, bodyParameters);
-            return JsonConvert.DeserializeObject<TResult>(resp.Content);
+            Request.AddParameter("access_token", credentials.AccessToken);
+            return DoRestRequestAsync<TResult>();
         }
 
-        //private async Task<TResult> DoRestRequestAsync<TResult>(IRestRequest request)
+        private TResult DoRestRequest<TResult>()
-        //{
+        {
-        //    var client = new RestClient(Constants.BaseRequestString);
+            var response = Client.Execute(this.Request);
-        //    var cancellationTokenSource = new CancellationTokenSource();
+            return JsonConvert.DeserializeObject<TResult>(response.Content);
-        //    var resp = await client.ExecuteTaskAsync(request, cancellationTokenSource.Token);
+        }
-        //    return JsonConvert.DeserializeObject<TResult>(resp.Content);
+
-        //}
+        private async Task<TResult> DoRestRequestAsync<TResult>()
+        {
+            var response = await Client.ExecuteTaskAsync(Request);
+            return JsonConvert.DeserializeObject<TResult>(response.Content);
+        }
     }
 }

src/Untappd.Net/Responses/UserBadges.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using Newtonsoft.Json;
 using Untappd.Net.Request;
-using System.ComponentModel;
 
 namespace Untappd.Net.Responses.UserBadges
 {

src/Untappd.Net/SingleObjectArrayConverter.cs

@@ -1,5 +1,6 @@
 using System;
 using Newtonsoft.Json;
+using Untappd.Net.Request;
 
 namespace Untappd.Net
 {
@@ -16,19 +17,20 @@ namespace Untappd.Net
         public override bool CanConvert(Type objectType)
         {
             return true;
+
         }
 
         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
         {
-            object retval = new Object();
+            var retval = new object();
 
-            if (reader.TokenType == JsonToken.StartObject)
+            switch (reader.TokenType)
             {
-                T instance = (T)serializer.Deserialize(reader, typeof(T));
+                case JsonToken.StartObject:
+                    var instance = (T)serializer.Deserialize(reader, typeof(T));
                 retval = instance;
-            }
+                    break;
-            else if (reader.TokenType == JsonToken.StartArray)
+                case JsonToken.StartArray:
-            {
                 reader.Read();
                 retval = new T();
             }