src/third_party/WebKit/Source/modules/websockets/WebSocketExtensionDispatcherTest.cpp

   1 /*
   2  * Copyright (C) 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "modules/websockets/WebSocketExtensionDispatcher.h"
  28
  29 #include "modules/websockets/WebSocketExtensionParser.h"
  30 #include "modules/websockets/WebSocketExtensionProcessor.h"
  31 #include "wtf/text/CString.h"
  32 #include "wtf/text/StringHash.h"
  33 #include <gtest/gtest.h>
  34
  35 namespace blink {
  36 namespace {
  37
  38 class WebSocketExtensionDispatcherTest;
  39
  40 class MockWebSocketExtensionProcessor FINAL : public WebSocketExtensionProcessor {
  41 public:
  42     MockWebSocketExtensionProcessor(const String& name, WebSocketExtensionDispatcherTest* test)
  43         : WebSocketExtensionProcessor(name)
  44         , m_test(test)
  45     {
  46     }
  47     virtual String handshakeString() OVERRIDE { return extensionToken(); }
  48     virtual bool processResponse(const HashMap<String, String>&) OVERRIDE;
  49
  50 private:
  51     WebSocketExtensionDispatcherTest* m_test;
  52 };
  53
  54 class WebSocketExtensionDispatcherTest : public testing::Test {
  55 public:
  56     WebSocketExtensionDispatcherTest() { }
  57
  58     void SetUp() { }
  59
  60     void TearDown() { }
  61
  62     void addMockProcessor(const String& extensionToken)
  63     {
  64         m_extensions.addProcessor(adoptPtr(new MockWebSocketExtensionProcessor(extensionToken, this)));
  65
  66     }
  67
  68     void appendResult(const String& extensionToken, const HashMap<String, String>& parameters)
  69     {
  70         m_parsedExtensionTokens.append(extensionToken);
  71         m_parsedParameters.append(parameters);
  72     }
  73
  74 protected:
  75     WebSocketExtensionDispatcher m_extensions;
  76     Vector<String> m_parsedExtensionTokens;
  77     Vector<HashMap<String, String> > m_parsedParameters;
  78 };
  79
  80 bool MockWebSocketExtensionProcessor::processResponse(const HashMap<String, String>& parameters)
  81 {
  82     m_test->appendResult(extensionToken(), parameters);
  83     return true;
  84 }
  85
  86 TEST_F(WebSocketExtensionDispatcherTest, TestSingle)
  87 {
  88     addMockProcessor("deflate-frame");
  89     EXPECT_TRUE(m_extensions.processHeaderValue("deflate-frame"));
  90     EXPECT_EQ(1UL, m_parsedExtensionTokens.size());
  91     EXPECT_EQ("deflate-frame", m_parsedExtensionTokens[0]);
  92     EXPECT_EQ("deflate-frame", m_extensions.acceptedExtensions());
  93     EXPECT_EQ(0UL, m_parsedParameters[0].size());
  94 }
  95
  96 TEST_F(WebSocketExtensionDispatcherTest, TestParameters)
  97 {
  98     addMockProcessor("mux");
  99     EXPECT_TRUE(m_extensions.processHeaderValue("mux; max-channels=4; flow-control  "));
 100     EXPECT_EQ(1UL, m_parsedExtensionTokens.size());
 101     EXPECT_EQ("mux", m_parsedExtensionTokens[0]);
 102     EXPECT_EQ(2UL, m_parsedParameters[0].size());
 103     HashMap<String, String>::iterator parameter = m_parsedParameters[0].find("max-channels");
 104     EXPECT_TRUE(parameter != m_parsedParameters[0].end());
 105     EXPECT_EQ("4", parameter->value);
 106     parameter = m_parsedParameters[0].find("flow-control");
 107     EXPECT_TRUE(parameter != m_parsedParameters[0].end());
 108     EXPECT_TRUE(parameter->value.isNull());
 109 }
 110
 111 TEST_F(WebSocketExtensionDispatcherTest, TestMultiple)
 112 {
 113     struct {
 114         String token;
 115         HashMap<String, String> parameters;
 116     } expected[2];
 117     expected[0].token = "mux";
 118     expected[0].parameters.add("max-channels", "4");
 119     expected[0].parameters.add("flow-control", String());
 120     expected[1].token = "deflate-frame";
 121
 122     addMockProcessor("mux");
 123     addMockProcessor("deflate-frame");
 124     EXPECT_TRUE(m_extensions.processHeaderValue("mux ;  max-channels =4;flow-control, deflate-frame  "));
 125     EXPECT_TRUE(m_extensions.acceptedExtensions().find("mux") != kNotFound);
 126     EXPECT_TRUE(m_extensions.acceptedExtensions().find("deflate-frame") != kNotFound);
 127     for (size_t i = 0; i < sizeof(expected) / sizeof(expected[0]); ++i) {
 128         EXPECT_EQ(expected[i].token, m_parsedExtensionTokens[i]);
 129         const HashMap<String, String>& expectedParameters = expected[i].parameters;
 130         const HashMap<String, String>& parsedParameters = m_parsedParameters[i];
 131         EXPECT_EQ(expected[i].parameters.size(), m_parsedParameters[i].size());
 132         for (HashMap<String, String>::const_iterator iterator = expectedParameters.begin(); iterator != expectedParameters.end(); ++iterator) {
 133             HashMap<String, String>::const_iterator parsed = parsedParameters.find(iterator->key);
 134             EXPECT_TRUE(parsed != parsedParameters.end());
 135             if (iterator->value.isNull())
 136                 EXPECT_TRUE(parsed->value.isNull());
 137             else
 138                 EXPECT_EQ(iterator->value, parsed->value);
 139         }
 140     }
 141 }
 142
 143 TEST_F(WebSocketExtensionDispatcherTest, TestQuotedString)
 144 {
 145     addMockProcessor("x-foo");
 146     ASSERT_TRUE(m_extensions.processHeaderValue("x-foo; param1=\"quoted-string\"; param2=\"quoted\\.string\""));
 147     EXPECT_EQ(2UL, m_parsedParameters[0].size());
 148     EXPECT_EQ("quoted-string", m_parsedParameters[0].get("param1"));
 149     EXPECT_EQ("quoted.string", m_parsedParameters[0].get("param2"));
 150 }
 151
 152 TEST_F(WebSocketExtensionDispatcherTest, TestInvalid)
 153 {
 154     const char* inputs[] = {
 155         "\"x-foo\"",
 156         "x-baz",
 157         "x-foo\\",
 158         "x-(foo)",
 159         "x-foo; ",
 160         "x-foo; bar=",
 161         "x-foo; bar=x y",
 162         "x-foo; bar=\"mismatch quote",
 163         "x-foo; bar=\"\\\"",
 164         "x-foo; \"bar\"=baz",
 165         "x-foo; bar=\"\"",
 166         "x-foo; bar=\" \"",
 167         "x-foo; bar=\"bar baz\"",
 168         "x-foo; bar=\"bar,baz\"",
 169         "x-foo; bar=\"ba\xffr,baz\"",
 170         "x-foo x-bar",
 171         "x-foo, x-baz"
 172         "x-foo, ",
 173     };
 174     for (size_t i = 0; i < sizeof(inputs) / sizeof(inputs[0]); ++i) {
 175         m_extensions.reset();
 176         addMockProcessor("x-foo");
 177         addMockProcessor("x-bar");
 178         EXPECT_FALSE(m_extensions.processHeaderValue(inputs[i]));
 179         EXPECT_TRUE(m_extensions.acceptedExtensions().isNull());
 180     }
 181 }
 182
 183 } // namespace
 184 } // namespace blink