added more tests to get build working

test/Ocelot.UnitTests/Infrastructure/ScopesAuthoriserTests.cs

@@ -0,0 +1,124 @@
+using Xunit;
+using Shouldly;
+using Ocelot.Authorisation;
+using Ocelot.Infrastructure.Claims.Parser;
+using Moq;
+using System.Collections.Generic;
+using System.Security.Claims;
+using Ocelot.Responses;
+using TestStack.BDDfy;
+using Ocelot.Errors;
+
+namespace Ocelot.UnitTests.Infrastructure
+{
+    public class ScopesAuthoriserTests
+    {
+        private ScopesAuthoriser _authoriser;
+        public Mock<IClaimsParser> _parser;
+        private ClaimsPrincipal _principal;
+        private List<string> _allowedScopes;
+        private Response<bool> _result;
+
+        public ScopesAuthoriserTests()
+        {
+            _parser = new Mock<IClaimsParser>();
+            _authoriser = new ScopesAuthoriser(_parser.Object);
+        }
+
+        [Fact]
+        public void should_return_ok_if_no_allowed_scopes()
+        {
+            this.Given(_ => GivenTheFollowing(new ClaimsPrincipal()))
+            .And(_ => GivenTheFollowing(new List<string>()))
+            .When(_ => WhenIAuthorise())
+            .Then(_ => ThenTheFollowingIsReturned(new OkResponse<bool>(true)))
+            .BDDfy();
+        }
+
+
+        [Fact]
+        public void should_return_ok_if_null_allowed_scopes()
+        {
+            this.Given(_ => GivenTheFollowing(new ClaimsPrincipal()))
+            .And(_ => GivenTheFollowing((List<string>)null))
+            .When(_ => WhenIAuthorise())
+            .Then(_ => ThenTheFollowingIsReturned(new OkResponse<bool>(true)))
+            .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_error_if_claims_parser_returns_error()
+        {
+            var fakeError = new FakeError();
+            this.Given(_ => GivenTheFollowing(new ClaimsPrincipal()))
+            .And(_ => GivenTheParserReturns(new ErrorResponse<List<string>>(fakeError)))
+            .And(_ => GivenTheFollowing(new List<string>(){"doesntmatter"}))
+            .When(_ => WhenIAuthorise())
+            .Then(_ => ThenTheFollowingIsReturned(new ErrorResponse<bool>(fakeError)))
+            .BDDfy();
+        }
+
+        [Fact]
+        public void should_match_scopes_and_return_ok_result()
+        {
+            var claimsPrincipal = new ClaimsPrincipal();
+            var allowedScopes = new List<string>(){"someScope"};
+
+            this.Given(_ => GivenTheFollowing(claimsPrincipal))
+            .And(_ => GivenTheParserReturns(new OkResponse<List<string>>(allowedScopes)))
+            .And(_ => GivenTheFollowing(allowedScopes))
+            .When(_ => WhenIAuthorise())
+            .Then(_ => ThenTheFollowingIsReturned(new OkResponse<bool>(true)))
+            .BDDfy();
+        }
+
+        [Fact]
+        public void should_not_match_scopes_and_return_error_result()
+        {
+            var fakeError = new FakeError();
+            var claimsPrincipal = new ClaimsPrincipal();
+            var allowedScopes = new List<string>(){"someScope"};
+            var userScopes = new List<string>(){"anotherScope"};
+
+            this.Given(_ => GivenTheFollowing(claimsPrincipal))
+            .And(_ => GivenTheParserReturns(new OkResponse<List<string>>(userScopes)))
+            .And(_ => GivenTheFollowing(allowedScopes))
+            .When(_ => WhenIAuthorise())
+            .Then(_ => ThenTheFollowingIsReturned(new ErrorResponse<bool>(fakeError)))
+            .BDDfy();
+        }
+
+        private void GivenTheParserReturns(Response<List<string>> response)
+        {
+            _parser.Setup(x => x.GetValuesByClaimType(It.IsAny<IEnumerable<Claim>>(), It.IsAny<string>())).Returns(response);
+        }
+
+        private void GivenTheFollowing(ClaimsPrincipal principal)
+        {
+            _principal = principal;
+        }
+
+        private void GivenTheFollowing(List<string> allowedScopes)
+        {
+            _allowedScopes = allowedScopes;
+        }
+
+        private void WhenIAuthorise()
+        {
+            _result = _authoriser.Authorise(_principal, _allowedScopes);
+        }
+
+        private void ThenTheFollowingIsReturned(Response<bool> expected)
+        {
+            _result.Data.ShouldBe(expected.Data);
+            _result.IsError.ShouldBe(expected.IsError);
+        }
+    }
+
+      public class FakeError : Error
+        {
+            public FakeError() : base("fake error", OcelotErrorCode.CannotAddDataError)
+            {
+            }
+        }
+}