path: root/csharp/src/ProtocolBuffers.Test/TestRpcForMimeTypes.cs

#region Copyright notice and license

// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc.  All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code:
// http://code.google.com/p/protobuf/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#endregion

using System;
using Google.ProtocolBuffers;
using Google.ProtocolBuffers.Serialization.Http;
using Google.ProtocolBuffers.TestProtos;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using Google.ProtocolBuffers.Serialization;
using System.Text;

namespace Google.ProtocolBuffers
{
    /// <summary>
    /// This class verifies the correct code is generated from unittest_rpc_interop.proto and provides a small demonstration
    /// of using the new IRpcDispatch to write a client/server
    /// </summary>
    [TestClass]
    public class TestRpcForMimeTypes
    {
        /// <summary>
        /// A sample implementation of the ISearchService for testing
        /// </summary>
        private class ExampleSearchImpl : ISearchService
        {
            SearchResponse ISearchService.Search(SearchRequest searchRequest)
            {
                if (searchRequest.CriteriaCount == 0)
                {
                    throw new ArgumentException("No criteria specified.", new InvalidOperationException());
                }
                SearchResponse.Builder resp = SearchResponse.CreateBuilder();
                foreach (string criteria in searchRequest.CriteriaList)
                {
                    resp.AddResults(
                        SearchResponse.Types.ResultItem.CreateBuilder().SetName(criteria).SetUrl("http://search.com").
                            Build());
                }
                return resp.Build();
            }

            SearchResponse ISearchService.RefineSearch(RefineSearchRequest refineSearchRequest)
            {
                SearchResponse.Builder resp = refineSearchRequest.PreviousResults.ToBuilder();
                foreach (string criteria in refineSearchRequest.CriteriaList)
                {
                    resp.AddResults(
                        SearchResponse.Types.ResultItem.CreateBuilder().SetName(criteria).SetUrl("http://refine.com").
                            Build());
                }
                return resp.Build();
            }
        }

        /// <summary>
        /// An example extraction of the wire protocol
        /// </summary>
        private interface IHttpTransfer
        {
            void Execute(string method, string contentType, Stream input, string acceptType, Stream output);
        }

        /// <summary>
        /// An example of a server responding to a web/http request
        /// </summary>
        private class ExampleHttpServer : IHttpTransfer
        {
            public readonly MessageFormatOptions Options =
                new MessageFormatOptions
                {
                    ExtensionRegistry = ExtensionRegistry.Empty,
                    FormattedOutput = true,
                    XmlReaderOptions = XmlReaderOptions.ReadNestedArrays,
                    XmlReaderRootElementName = "request",
                    XmlWriterOptions = XmlWriterOptions.OutputNestedArrays,
                    XmlWriterRootElementName = "response"
                };

            private readonly IRpcServerStub _stub;

            public ExampleHttpServer(ISearchService implementation)
            {
                //on the server, we create a dispatch to call the appropriate method by name
                IRpcDispatch dispatch = new SearchService.Dispatch(implementation);
                //we then wrap that dispatch in a server stub which will deserialize the wire bytes to the message
                //type appropriate for the method name being invoked.
                _stub = new SearchService.ServerStub(dispatch);
            }

            void IHttpTransfer.Execute(string method, string contentType, Stream input, string acceptType, Stream output)
            {
                //3.5: _stub.HttpCallMethod(
                Extensions.HttpCallMethod(_stub,
                    method, Options,
                    contentType, input,
                    acceptType, output
                    );
            }
        }

        /// <summary>
        /// An example of a client sending a wire request
        /// </summary>
        private class ExampleClient : IRpcDispatch
        {
            public readonly MessageFormatOptions Options =
                new MessageFormatOptions
                {
                    ExtensionRegistry = ExtensionRegistry.Empty,
                    FormattedOutput = true,
                    XmlReaderOptions = XmlReaderOptions.ReadNestedArrays,
                    XmlReaderRootElementName = "response",
                    XmlWriterOptions = XmlWriterOptions.OutputNestedArrays,
                    XmlWriterRootElementName = "request"
                };


            private readonly IHttpTransfer _wire;
            private readonly string _mimeType;

            public ExampleClient(IHttpTransfer wire, string mimeType)
            {
                _wire = wire;
                _mimeType = mimeType;
            }

            TMessage IRpcDispatch.CallMethod<TMessage, TBuilder>(string method, IMessageLite request,
                                                                 IBuilderLite<TMessage, TBuilder> response)
            {
                MemoryStream input = new MemoryStream();
                MemoryStream output = new MemoryStream();

                //Write to _mimeType format
                Extensions.WriteTo(request, Options, _mimeType, input);

                input.Position = 0;
                _wire.Execute(method, _mimeType, input, _mimeType, output);

                //Read from _mimeType format
                output.Position = 0;
                Extensions.MergeFrom(response, Options, _mimeType, output);
                
                return response.Build();
            }
        }

        /// <summary>
        /// Test sending and recieving messages via text/json
        /// </summary>
        [TestMethod]
        public void TestClientServerWithJsonFormat()
        {
            ExampleHttpServer server = new ExampleHttpServer(new ExampleSearchImpl());
            //obviously if this was a 'real' transport we would not use the server, rather the server would be listening, the client transmitting
            IHttpTransfer wire = server;

            ISearchService client = new SearchService(new ExampleClient(wire, "text/json"));
            //now the client has a real, typed, interface to work with:
            SearchResponse result = client.Search(SearchRequest.CreateBuilder().AddCriteria("Test").Build());
            Assert.AreEqual(1, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            //The test part of this, call the only other method
            result =
                client.RefineSearch(
                    RefineSearchRequest.CreateBuilder().SetPreviousResults(result).AddCriteria("Refine").Build());
            Assert.AreEqual(2, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            Assert.AreEqual("Refine", result.ResultsList[1].Name);
            Assert.AreEqual("http://refine.com", result.ResultsList[1].Url);
        }

        /// <summary>
        /// Test sending and recieving messages via text/json
        /// </summary>
        [TestMethod]
        public void TestClientServerWithXmlFormat()
        {
            ExampleHttpServer server = new ExampleHttpServer(new ExampleSearchImpl());
            //obviously if this was a 'real' transport we would not use the server, rather the server would be listening, the client transmitting
            IHttpTransfer wire = server;

            ISearchService client = new SearchService(new ExampleClient(wire, "text/xml"));
            //now the client has a real, typed, interface to work with:
            SearchResponse result = client.Search(SearchRequest.CreateBuilder().AddCriteria("Test").Build());
            Assert.AreEqual(1, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            //The test part of this, call the only other method
            result =
                client.RefineSearch(
                    RefineSearchRequest.CreateBuilder().SetPreviousResults(result).AddCriteria("Refine").Build());
            Assert.AreEqual(2, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            Assert.AreEqual("Refine", result.ResultsList[1].Name);
            Assert.AreEqual("http://refine.com", result.ResultsList[1].Url);
        }

        /// <summary>
        /// Test sending and recieving messages via text/json
        /// </summary>
        [TestMethod]
        public void TestClientServerWithProtoFormat()
        {
            ExampleHttpServer server = new ExampleHttpServer(new ExampleSearchImpl());
            //obviously if this was a 'real' transport we would not use the server, rather the server would be listening, the client transmitting
            IHttpTransfer wire = server;

            ISearchService client = new SearchService(new ExampleClient(wire, "application/x-protobuf"));
            //now the client has a real, typed, interface to work with:
            SearchResponse result = client.Search(SearchRequest.CreateBuilder().AddCriteria("Test").Build());
            Assert.AreEqual(1, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            //The test part of this, call the only other method
            result =
                client.RefineSearch(
                    RefineSearchRequest.CreateBuilder().SetPreviousResults(result).AddCriteria("Refine").Build());
            Assert.AreEqual(2, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            Assert.AreEqual("Refine", result.ResultsList[1].Name);
            Assert.AreEqual("http://refine.com", result.ResultsList[1].Url);
        }

        /// <summary>
        /// Test sending and recieving messages via text/json
        /// </summary>
        [TestMethod]
        public void TestClientServerWithCustomFormat()
        {
            ExampleHttpServer server = new ExampleHttpServer(new ExampleSearchImpl());
            //Setup our custom mime-type format as the only format supported:
            server.Options.MimeInputTypes.Clear();
            server.Options.MimeInputTypes.Add("foo/bar", CodedInputStream.CreateInstance);
            server.Options.MimeOutputTypes.Clear();
            server.Options.MimeOutputTypes.Add("foo/bar", CodedOutputStream.CreateInstance);

            //obviously if this was a 'real' transport we would not use the server, rather the server would be listening, the client transmitting
            IHttpTransfer wire = server;

            ExampleClient exclient = new ExampleClient(wire, "foo/bar");
            //Add our custom mime-type format
            exclient.Options.MimeInputTypes.Add("foo/bar", CodedInputStream.CreateInstance);
            exclient.Options.MimeOutputTypes.Add("foo/bar", CodedOutputStream.CreateInstance);
            ISearchService client = new SearchService(exclient);

            //now the client has a real, typed, interface to work with:
            SearchResponse result = client.Search(SearchRequest.CreateBuilder().AddCriteria("Test").Build());
            Assert.AreEqual(1, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            //The test part of this, call the only other method
            result =
                client.RefineSearch(
                    RefineSearchRequest.CreateBuilder().SetPreviousResults(result).AddCriteria("Refine").Build());
            Assert.AreEqual(2, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            Assert.AreEqual("Refine", result.ResultsList[1].Name);
            Assert.AreEqual("http://refine.com", result.ResultsList[1].Url);
        }

        /// <summary>
        /// Test sending and recieving messages via text/json
        /// </summary>
        [TestMethod]
        public void TestServerWithUriFormat()
        {
            ExampleHttpServer server = new ExampleHttpServer(new ExampleSearchImpl());
            //obviously if this was a 'real' transport we would not use the server, rather the server would be listening, the client transmitting
            IHttpTransfer wire = server;

            MemoryStream input = new MemoryStream(Encoding.UTF8.GetBytes("?Criteria=Test&Criteria=Test+of%20URI"));
            MemoryStream output = new MemoryStream();

            //Call the server
            wire.Execute("Search",
                         MessageFormatOptions.ContentFormUrlEncoded, input,
                         MessageFormatOptions.ContentTypeProtoBuffer, output
                         );

            SearchResponse result = SearchResponse.ParseFrom(output.ToArray());
            Assert.AreEqual(2, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);

            Assert.AreEqual("Test of URI", result.ResultsList[1].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[1].Url);
        }

        /// <summary>
        /// Test sending and recieving messages via text/json
        /// </summary>
        [TestMethod, ExpectedException(typeof(ArgumentOutOfRangeException))]
        public void TestInvalidMimeType()
        {
            ExampleHttpServer server = new ExampleHttpServer(new ExampleSearchImpl());
            //obviously if this was a 'real' transport we would not use the server, rather the server would be listening, the client transmitting
            IHttpTransfer wire = server;

            MemoryStream input = new MemoryStream();
            MemoryStream output = new MemoryStream();

            //Call the server
            wire.Execute("Search",
                         "bad/mime", input,
                         MessageFormatOptions.ContentTypeProtoBuffer, output
                         );
            Assert.Fail();
        }

        /// <summary>
        /// Test sending and recieving messages via text/json
        /// </summary>
        [TestMethod]
        public void TestDefaultMimeType()
        {
            ExampleHttpServer server = new ExampleHttpServer(new ExampleSearchImpl());
            
            //obviously if this was a 'real' transport we would not use the server, rather the server would be listening, the client transmitting
            IHttpTransfer wire = server;


            MemoryStream input = new MemoryStream(new SearchRequest.Builder().AddCriteria("Test").Build().ToByteArray());
            MemoryStream output = new MemoryStream();

            //With this default set, any invalid/unknown mime-type will be mapped to use that format
            server.Options.DefaultContentType = MessageFormatOptions.ContentTypeProtoBuffer;

            wire.Execute("Search",
                         "foo", input,
                         "bar", output
                         );

            SearchResponse result = SearchResponse.ParseFrom(output.ToArray());
            Assert.AreEqual(1, result.ResultsCount);
            Assert.AreEqual("Test", result.ResultsList[0].Name);
            Assert.AreEqual("http://search.com", result.ResultsList[0].Url);
        }
    }
}