orthanc: UnitTestsSources/RestApiTests.cpp comparison

comparison UnitTestsSources/RestApiTests.cpp @ 1782:9f2df9bb2cdf

fix

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 18 Nov 2015 09:05:43 +0100
parents	5ad4e4d92ecb
children	dbb07eb1a2f3

comparison

equal deleted inserted replaced

-:5ad4e4d92ecb
+:9f2df9bb2cdf
 namespace Orthanc
 {
-class AcceptMediaDispatcher : public boost::noncopyable
+class HttpContentNegociation : public boost::noncopyable
 {
 public:
 typedef std::map<std::string, std::string>  HttpHeaders;
 class IHandler : public boost::noncopyable
 virtual ~IHandler()
 {
 }
 virtual void Handle(const std::string& type,
-const std::string& subtype,
+const std::string& subtype) = 0;
-float quality /* between 0 and 1 */) = 0;
 };
 private:
 struct Handler
 {
 return true;
 }
 return type == type_ && subtype == subtype_;
 }
+void Call() const
+{
+handler_.Handle(type_, subtype_);
+}
 };
 struct Reference : public boost::noncopyable
 {
 const Handler&  handler_;
 uint8_t         level_;
 float           quality_;
-size_t          specificity_;   // Number of arguments
 Reference(const Handler& handler,
 const std::string& type,
 const std::string& subtype,
-float quality,
+float quality) :
-size_t specificity) :
 handler_(handler),
-quality_(quality),
+quality_(quality)
-specificity_(specificity)
 {
 if (type == "*" && subtype == "*")
 {
 level_ = 0;
 }
 if (level_ > other.level_)
 {
 return false;
 }
-return specificity_ < other.specificity_;
+return quality_ < other.quality_;
-}
-void Call() const
-{
-handler_.handler_.Handle(handler_.type_, handler_.subtype_, quality_);
 }
 };
 typedef std::vector<std::string>  Tokens;
 return true;
 }
 }
-static void GetQualityAndSpecificity(float& quality /* out */,
+static float GetQuality(const Tokens& parameters)
-size_t& specificity /* out */,
+{
-const Tokens& parameters)
-{
-assert(!parameters.empty());
-quality = 1.0f;
-specificity = parameters.size() - 1;
 for (size_t i = 1; i < parameters.size(); i++)
 {
 std::string key, value;
 if (SplitPair(key, value, parameters[i], '=') &&
 key == "q")
 {
+float quality;
 bool ok = false;
 try
 {
 quality = boost::lexical_cast<float>(value);
 {
 }
 if (ok)
 {
-assert(parameters.size() >= 2);
+return quality;
-specificity = parameters.size() - 2;
-return;
 }
 else
 {
 LOG(ERROR) << "Quality parameter out of range in a HTTP request (must be between 0 and 1): " << value;
-throw OrthancException(ErrorCode_ParameterOutOfRange);
+throw OrthancException(ErrorCode_BadRequest);
 }
 }
 }
+return 1.0f;  // Default quality
 }
 static void SelectBestMatch(std::auto_ptr<Reference>& best,
 const Handler& handler,
 const std::string& type,
 const std::string& subtype,
-float quality,
+float quality)
-size_t specificity)
+{
-{
+std::auto_ptr<Reference> match(new Reference(handler, type, subtype, quality));
-std::auto_ptr<Reference> match(new Reference(handler, type, subtype, quality, specificity));
 if (best.get() == NULL ||
 *best < *match)
 {
 best = match;
 bool Apply(const std::string& accept)
 {
 // http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
+// https://en.wikipedia.org/wiki/Content_negotiation
+// http://www.newmediacampaigns.com/blog/browser-rest-http-accept-headers
 Tokens mediaRanges;
 Toolbox::TokenizeString(mediaRanges, accept, ',');
 std::auto_ptr<Reference> bestMatch;
-for (Tokens::const_reverse_iterator it = mediaRanges.rbegin();
+for (Tokens::const_iterator it = mediaRanges.begin();
-it != mediaRanges.rend(); ++it)
+it != mediaRanges.end(); ++it)
 {
 Tokens parameters;
 Toolbox::TokenizeString(parameters, *it, ';');
 if (parameters.size() > 0)
 {
-float quality;
+float quality = GetQuality(parameters);
-size_t specificity;
-GetQualityAndSpecificity(quality, specificity, parameters);
 std::string type, subtype;
 if (SplitPair(type, subtype, parameters[0], '/'))
 {
 for (Handlers::const_iterator it2 = handlers_.begin();
 it2 != handlers_.end(); ++it2)
 {
 if (it2->IsMatch(type, subtype))
 {
-SelectBestMatch(bestMatch, *it2, type, subtype, quality, specificity);
+SelectBestMatch(bestMatch, *it2, type, subtype, quality);
 }
 }
 }
 }
 }
 {
 return false;
 }
 else
 {
-bestMatch->Call();
+bestMatch->handler_.Call();
 return true;
 }
 }
 };
 }
 namespace
 {
-class AcceptHandler : public Orthanc::AcceptMediaDispatcher::IHandler
+class AcceptHandler : public Orthanc::HttpContentNegociation::IHandler
 {
 private:
 std::string type_;
 std::string subtype_;
-float quality_;
 public:
 AcceptHandler()
 {
 Reset();
 }
 void Reset()
 {
-Handle("nope", "nope", 0.0f);
+Handle("nope", "nope");
 }
 const std::string& GetType() const
 {
 return type_;
 const std::string& GetSubType() const
 {
 return subtype_;
 }
-float GetQuality() const
-{
-return quality_;
-}
 virtual void Handle(const std::string& type,
-const std::string& subtype,
+const std::string& subtype)
-float quality /* between 0 and 1 */)
 {
 type_ = type;
 subtype_ = subtype;
-quality_ = quality;
 }
 };
 }
-TEST(RestApi, AcceptMediaDispatcher)
+TEST(RestApi, HttpContentNegociation)
 {
 // Reference: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
 AcceptHandler h;
 {
-Orthanc::AcceptMediaDispatcher d;
+Orthanc::HttpContentNegociation d;
 d.Register("audio/mp3", h);
 d.Register("audio/basic", h);
 ASSERT_TRUE(d.Apply("audio/*; q=0.2, audio/basic"));
 ASSERT_EQ("audio", h.GetType());
 ASSERT_EQ("basic", h.GetSubType());
-ASSERT_FLOAT_EQ(1.0f, h.GetQuality());
 ASSERT_TRUE(d.Apply("audio/*; q=0.2, audio/nope"));
 ASSERT_EQ("audio", h.GetType());
 ASSERT_EQ("mp3", h.GetSubType());
-ASSERT_FLOAT_EQ(0.2f, h.GetQuality());
 ASSERT_FALSE(d.Apply("application/*; q=0.2, application/pdf"));
 ASSERT_TRUE(d.Apply("*/*; application/*; q=0.2, application/pdf"));
 ASSERT_EQ("audio", h.GetType());
 // text/x-dvi entity, and if that does not exist, send the
 // text/plain entity.""
 const std::string T1 = "text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c";
 {
-Orthanc::AcceptMediaDispatcher d;
+Orthanc::HttpContentNegociation d;
 d.Register("text/plain", h);
-//d.Register("text/x-dvi", h);
 d.Register("text/html", h);
+d.Register("text/x-dvi", h);
 ASSERT_TRUE(d.Apply(T1));
 ASSERT_EQ("text", h.GetType());
 ASSERT_EQ("html", h.GetSubType());
-ASSERT_EQ(1.0f, h.GetQuality());
 }
 {
-Orthanc::AcceptMediaDispatcher d;
+Orthanc::HttpContentNegociation d;
 d.Register("text/plain", h);
-//d.Register("text/x-dvi", h);
+d.Register("text/x-dvi", h);
 d.Register("text/x-c", h);
 ASSERT_TRUE(d.Apply(T1));
 ASSERT_EQ("text", h.GetType());
 ASSERT_EQ("x-c", h.GetSubType());
-ASSERT_EQ(1.0f, h.GetQuality());
 }
 {
-Orthanc::AcceptMediaDispatcher d;
+Orthanc::HttpContentNegociation d;
+d.Register("text/plain", h);
+d.Register("text/x-dvi", h);
+d.Register("text/x-c", h);
+d.Register("text/html", h);
+ASSERT_TRUE(d.Apply(T1));
+ASSERT_EQ("text", h.GetType());
+ASSERT_TRUE(h.GetSubType() == "x-c" || h.GetSubType() == "html");
+}
+{
+Orthanc::HttpContentNegociation d;
 d.Register("text/plain", h);
 d.Register("text/x-dvi", h);
 ASSERT_TRUE(d.Apply(T1));
 ASSERT_EQ("text", h.GetType());
 ASSERT_EQ("x-dvi", h.GetSubType());
-ASSERT_EQ(0.8f, h.GetQuality());
 }
 {
-Orthanc::AcceptMediaDispatcher d;
+Orthanc::HttpContentNegociation d;
 d.Register("text/plain", h);
 ASSERT_TRUE(d.Apply(T1));
 ASSERT_EQ("text", h.GetType());
 ASSERT_EQ("plain", h.GetSubType());
-ASSERT_EQ(0.5f, h.GetQuality());
+}
 }
-}

Mercurial > hg > orthanc

comparison UnitTestsSources/RestApiTests.cpp @ 1782:9f2df9bb2cdf