em-http-request-samesite 0.1.1

data/spec/digest_auth_spec.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+$: << 'lib' << '../lib'
+
+require 'em-http/middleware/digest_auth'
+
+describe 'Digest Auth Authentication header generation' do
+  before :each do
+    @reference_header = 'Digest username="digest_username", realm="DigestAuth_REALM", algorithm=MD5, uri="/", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", response="96829962ffc31fa2852f86dc7f9f609b", opaque="BzdNK3gsJ2ixTrBJ"'
+  end
+
+  it 'should generate the correct header'  do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username',
+      password: 'digest_password'
+    }
+
+    middleware = EM::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should == @reference_header
+  end
+
+  it 'should not generate the same header for a different user' do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username_2',
+      password: 'digest_password'
+    }
+
+    middleware = EM::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should_not == @reference_header
+  end
+
+  it 'should not generate the same header if the nounce changes' do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg6", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username_2',
+      password: 'digest_password'
+    }
+
+    middleware = EM::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should_not == @reference_header
+  end
+
+end

data/spec/dns_spec.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+describe EventMachine::HttpRequest do
+
+  it "should fail gracefully on an invalid host in Location header" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/redirect/badhost', :connect_timeout => 0.1).get :redirects => 1
+      http.callback { failed(http) }
+      http.errback {
+        http.error.should match(/unable to resolve (server |)address/)
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should fail GET on DNS timeout" do
+    EventMachine.run {
+      EventMachine.heartbeat_interval = 0.1
+      http = EventMachine::HttpRequest.new('http://127.1.1.1/', :connect_timeout => 0.1).get
+      http.callback { failed(http) }
+      http.errback {
+        http.response_header.status.should == 0
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should fail GET on invalid host" do
+    EventMachine.run {
+      EventMachine.heartbeat_interval = 0.1
+      http = EventMachine::HttpRequest.new('http://somethinglocal/', :connect_timeout => 0.1).get
+      http.callback { failed(http) }
+      http.errback {
+        http.error.should match(/unable to resolve (server |)address/)
+        http.response_header.status.should == 0
+        EventMachine.stop
+      }
+    }
+  end
+
+end

data/spec/encoding_spec.rb

@@ -0,0 +1,49 @@
+# -*- encoding: utf-8 -*-
+
+require 'helper'
+
+describe EventMachine::HttpEncoding do
+  include EventMachine::HttpEncoding
+
+  it "should transform a basic hash into HTTP POST Params" do
+    form_encode_body({:a => "alpha", :b => "beta"}).should == "a=alpha&b=beta"
+  end
+
+  it "should transform a more complex hash into HTTP POST Params" do
+    form_encode_body({:a => "a", :b => ["c", "d", "e"]}).should == "a=a&b[0]=c&b[1]=d&b[2]=e"
+  end
+
+  it "should transform a very complex hash into HTTP POST Params" do
+    params = form_encode_body({:a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]})
+    # 1.8.7 does not have ordered hashes.
+    params.split(/&/).sort.join('&').should == "a=a&b[0][c]=c&b[0][d]=d&b[1][e]=e&b[1][f]=f"
+  end
+
+  it "should escape values" do
+    params = form_encode_body({:stuff => 'string&string'})
+    params.should == "stuff=string%26string"
+  end
+
+  it "should escape keys" do
+    params = form_encode_body({'bad&str'=> {'key&key' => [:a, :b]}})
+    params.should == 'bad%26str[key%26key][0]=a&bad%26str[key%26key][1]=b'
+  end
+
+  it "should escape keys and values" do
+    params = form_encode_body({'bad&str'=> {'key&key' => ['bad+&stuff', '[test]']}})
+    params.should == "bad%26str[key%26key][0]=bad%2B%26stuff&bad%26str[key%26key][1]=%5Btest%5D"
+  end
+
+  it "should not issue warnings on non-ASCII encodings" do
+    # I don't know how to check for ruby warnings.
+    params = escape('valö')
+    params = escape('valö'.encode('ISO-8859-15'))
+  end
+
+  # xit "should be fast on long string escapes" do
+  #   s = Time.now
+  #   5000.times { |n| form_encode_body({:a => "{a:'b', d:'f', g:['a','b']}"*50}) }
+  #   (Time.now - s).should satisfy { |t| t < 1.5 }
+  # end
+
+end

data/spec/external_spec.rb

@@ -0,0 +1,150 @@
+require 'helper'
+
+requires_connection do
+
+  describe EventMachine::HttpRequest do
+
+    it "should follow redirects on HEAD method (external)" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://www.google.com/').head :redirects => 1
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          EM.stop
+        }
+      }
+    end
+
+    it "should follow redirect to https and initiate the handshake" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://github.com/').get :redirects => 5
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should perform a streaming GET" do
+      EventMachine.run {
+
+        # digg.com uses chunked encoding
+        http = EventMachine::HttpRequest.new('http://www.httpwatch.com/httpgallery/chunked/').get
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should handle a 100 continue" do
+      EventMachine.run {
+        # 8.2.3 Use of the 100 (Continue) Status - http://www.ietf.org/rfc/rfc2616.txt
+        #
+        # An origin server SHOULD NOT send a 100 (Continue) response if
+        # the request message does not include an Expect request-header
+        # field with the "100-continue" expectation, and MUST NOT send a
+        # 100 (Continue) response if such a request comes from an HTTP/1.0
+        # (or earlier) client. There is an exception to this rule: for
+        # compatibility with RFC 2068, a server MAY send a 100 (Continue)
+        # status in response to an HTTP/1.1 PUT or POST request that does
+        # not include an Expect request-header field with the "100-
+        # continue" expectation. This exception, the purpose of which is
+        # to minimize any client processing delays associated with an
+        # undeclared wait for 100 (Continue) status, applies only to
+        # HTTP/1.1 requests, and not to requests with any other HTTP-
+        # version value.
+        #
+        # 10.1.1: 100 Continue - http://www.ietf.org/rfc/rfc2068.txt
+        # The client may continue with its request. This interim response is
+        # used to inform the client that the initial part of the request has
+        # been received and has not yet been rejected by the server. The client
+        # SHOULD continue by sending the remainder of the request or, if the
+        # request has already been completed, ignore this response. The server
+        # MUST send a final response after the request has been completed.
+
+        url = 'http://ws.serviceobjects.com/lv/LeadValidation.asmx/ValidateLead_V2'
+        http = EventMachine::HttpRequest.new(url).post :body => {:name => :test}
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 500
+          http.response.should match('Missing')
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should detect deflate encoding" do
+      # pending "need an endpoint which supports deflate.. MSN is no longer"
+      EventMachine.run {
+
+        options = {:head => {"accept-encoding" => "deflate"}, :redirects => 5}
+        http = EventMachine::HttpRequest.new('http://www.libpng.org/').get options
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header["CONTENT_ENCODING"].should == "deflate"
+
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should stream chunked gzipped data" do
+      EventMachine.run {
+        options = {:head => {"accept-encoding" => "gzip"}}
+        # GitHub sends chunked gzip, time for a little Inception ;)
+        http = EventMachine::HttpRequest.new('https://github.com/igrigorik/em-http-request/commits/master').get options
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.response_header["CONTENT_ENCODING"].should == "gzip"
+          http.response.should == ''
+
+          EventMachine.stop
+        }
+
+        body = ''
+        http.stream do |chunk|
+          body << chunk
+        end
+      }
+    end
+
+    context "keepalive" do
+      it "should default to non-keepalive" do
+        EventMachine.run {
+          headers = {'If-Modified-Since' => 'Thu, 05 Aug 2010 22:54:44 GMT'}
+          http = EventMachine::HttpRequest.new('http://www.google.com/images/logos/ps_logo2.png').get :head => headers
+
+          http.errback { fail }
+          start = Time.now.to_i
+          http.callback {
+            (Time.now.to_i - start).should be_within(2).of(0)
+            EventMachine.stop
+          }
+        }
+      end
+
+      it "should work with keep-alive servers" do
+        EventMachine.run {
+          http = EventMachine::HttpRequest.new('https://github.com/igrigorik/em-http-request').get :keepalive => true
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            EventMachine.stop
+          }
+        }
+      end
+    end
+
+  end
+end

data/spec/fixtures/google.ca

@@ -0,0 +1,16 @@
+HTTP/1.1 301 Moved Permanently
+Location: http://www.google.ca/
+Content-Type: text/html; charset=UTF-8
+Date: Sun, 09 Jan 2011 02:51:43 GMT
+Expires: Tue, 08 Feb 2011 02:51:43 GMT
+Cache-Control: public, max-age=2592000
+Server: gws
+Content-Length: 218
+X-XSS-Protection: 1; mode=block
+
+<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
+<TITLE>301 Moved</TITLE></HEAD><BODY>
+<H1>301 Moved</H1>
+The document has moved
+<A HREF="http://www.google.ca/">here</A>.
+</BODY></HTML>

data/spec/gzip_spec.rb

@@ -0,0 +1,91 @@
+require 'helper'
+
+describe EventMachine::HttpDecoders::GZip do
+
+  let(:compressed) {
+    compressed = ["1f8b08089668a6500003686900cbc8e402007a7a6fed03000000"].pack("H*")
+  }
+
+  it "should extract the stream of a vanilla gzip" do
+    header = EventMachine::HttpDecoders::GZipHeader.new
+    stream = header.extract_stream(compressed)
+
+    stream.unpack("H*")[0].should eq("cbc8e402007a7a6fed03000000")
+  end
+
+  it "should decompress a vanilla gzip" do
+    decompressed = ""
+
+    gz = EventMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    gz << compressed
+    gz.finalize!
+
+    decompressed.should eq("hi\n")
+  end
+
+  it "should decompress a vanilla gzip file byte by byte" do
+    decompressed = ""
+
+    gz = EventMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    compressed.each_char do |byte|
+      gz << byte
+    end
+
+    gz.finalize!
+
+    decompressed.should eq("hi\n")
+  end
+
+  it "should decompress a large file" do
+    decompressed = ""
+
+    gz = EventMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    gz << File.read(File.dirname(__FILE__) + "/fixtures/gzip-sample.gz")
+
+    gz.finalize!
+
+    decompressed.size.should eq(32907)
+  end
+
+  it "should not care how many chunks the file is split up into" do
+    examples = [
+      ["\x1F", "\x8B", "\b", "\x00", "\x00", "\x00", "\x00", "\x00", "\x00", "\x00", "\xF3", "\xCB", "/", "Q", "p\xCB/\xCDK\x01\x00M\x8Ct\xB1\t\x00\x00\x00"],
+      ["\x1F", "\x8B", "\b", "\x00", "\x00", "\x00", "\x00", "\x00\x00\x00\xF3\xCB/Qp\xCB/\xCDK\x01\x00M\x8Ct\xB1\t\x00\x00\x00"]
+    ]
+
+    examples.each do |example|
+      decompressed = ""
+
+      gz = EventMachine::HttpDecoders::GZip.new do |data|
+        decompressed << data
+      end
+
+      example.each do |bytes|
+        gz << bytes
+      end
+
+      gz.finalize!
+
+      decompressed.should eq("Not Found")
+    end
+  end
+
+  it "should fail with a DecoderError if not a gzip file" do
+    not_a_gzip = ["1f8c08089668a650000"].pack("H*")
+    header = EventMachine::HttpDecoders::GZipHeader.new
+
+    lambda {
+      header.extract_stream(not_a_gzip)
+    }.should raise_exception(EventMachine::HttpDecoders::DecoderError)
+  end
+
+end

data/spec/helper.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'rubygems'
+require 'bundler/setup'
+
+require 'em-http'
+require 'em-http/middleware/oauth2'
+require 'multi_json'
+
+require 'stallion'
+require 'stub_server'
+
+def failed(http = nil)
+  EventMachine.stop
+  http ? fail(http.error) : fail
+end
+
+def requires_connection(&blk)
+  blk.call if system('ping -t1 -c1 google.com 2>&1 > /dev/null')
+end
+
+def requires_port(port, &blk)
+  port_open = true
+  begin
+    s = TCPSocket.new('localhost', port)
+    s.close()
+  rescue
+    port_open = false
+  end
+
+  blk.call if port_open
+end

data/spec/http_proxy_spec.rb

@@ -0,0 +1,268 @@
+require 'helper'
+
+shared_examples "*_PROXY var (through proxy)" do
+  it "should use HTTP proxy" do
+    EventMachine.run {
+      http = EventMachine::HttpRequest.new("#{proxy_test_scheme}://127.0.0.1:8090/?q=test").get
+
+      http.errback { failed(http) }
+      http.callback {
+        http.response_header.status.should == 200
+        http.response_header.should_not include("X_PROXY_AUTH")
+        http.response.should match('test')
+        EventMachine.stop
+      }
+    }
+  end
+end
+
+shared_examples "*_PROXY var (testing var)" do
+  subject { HttpConnectionOptions.new("#{proxy_test_scheme}://example.com", {}) }
+  it { expect(subject.proxy_from_env).to eq({ :host => "127.0.0.1", :port => 8083, :type => :http }) }
+  it { expect(subject.host).to eq "127.0.0.1" }
+  it { expect(subject.port).to be 8083 }
+  it do
+    case proxy_test_scheme.to_sym
+    when :http
+      expect(subject.http_proxy?).to be_truthy
+    when :https
+      expect(subject.connect_proxy?).to be_truthy
+    end
+  end
+end
+
+describe EventMachine::HttpRequest do
+
+  context "connections via" do
+    context "without *_PROXY env" do
+      let(:proxy) { {:proxy => { :host => '127.0.0.1', :port => 8083 }} }
+      let(:authenticated_proxy) { {:proxy => { :host => '127.0.0.1', :port => 8083, :authorization => ["user", "name"] } } }
+
+      it "should use HTTP proxy" do
+        EventMachine.run {
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/?q=test', proxy).get
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.response_header.should_not include("X_PROXY_AUTH")
+            http.response.should match('test')
+            EventMachine.stop
+          }
+        }
+      end
+
+      it "should use HTTP proxy with authentication" do
+        EventMachine.run {
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/proxyauth?q=test', authenticated_proxy).get
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.response_header['X_PROXY_AUTH'].should == "Proxy-Authorization: Basic dXNlcjpuYW1l"
+            http.response.should match('test')
+            EventMachine.stop
+          }
+        }
+      end
+
+      it "should send absolute URIs to the proxy server" do
+        EventMachine.run {
+
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/?q=test', proxy).get
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+
+            # The test proxy server gives the requested uri back in this header
+            http.response_header['X_THE_REQUESTED_URI'].should == 'http://127.0.0.1:8090/?q=test'
+            http.response_header['X_THE_REQUESTED_URI'].should_not == '/?q=test'
+            http.response.should match('test')
+            EventMachine.stop
+          }
+        }
+      end
+
+      it "should strip basic auth from before the host in URI sent to proxy" do
+        EventMachine.run {
+
+          http = EventMachine::HttpRequest.new('http://user:pass@127.0.0.1:8090/echo_authorization_header', proxy).get
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            # The test proxy server gives the requested uri back in this header
+            http.response_header['X_THE_REQUESTED_URI'].should == 'http://127.0.0.1:8090/echo_authorization_header'
+            # Ensure the basic auth was converted to a header correctly
+            http.response.should match('authorization:Basic dXNlcjpwYXNz')
+            EventMachine.stop
+          }
+        }
+      end
+
+      it "should include query parameters specified in the options" do
+        EventMachine.run {
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/', proxy).get :query => { 'q' => 'test' }
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+            http.response.should match('test')
+            EventMachine.stop
+          }
+        }
+      end
+
+      it "should use HTTP proxy while redirecting" do
+        EventMachine.run {
+          http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/redirect', proxy).get :redirects => 1
+
+          http.errback { failed(http) }
+          http.callback {
+            http.response_header.status.should == 200
+
+            http.response_header['X_THE_REQUESTED_URI'].should == 'http://127.0.0.1:8090/gzip'
+            http.response_header['X_THE_REQUESTED_URI'].should_not == '/redirect'
+
+            http.response_header["CONTENT_ENCODING"].should == "gzip"
+            http.response.should == "compressed"
+            http.last_effective_url.to_s.should == 'http://127.0.0.1:8090/gzip'
+            http.redirects.should == 1
+
+            EventMachine.stop
+          }
+        }
+      end
+    end
+
+    context "when parsing *_PROXY var (through proxy)s" do
+      context "with $HTTP_PROXY env" do
+        let(:proxy_test_scheme) { :http }
+
+        before(:all) do
+          PROXY_ENV_VARS.each {|k| ENV.delete k }
+          ENV['HTTP_PROXY'] = 'http://127.0.0.1:8083'
+        end
+
+        include_examples "*_PROXY var (through proxy)"
+      end
+
+      context "with $http_proxy env" do
+        let(:proxy_test_scheme) { :http }
+
+        before(:all) do
+          PROXY_ENV_VARS.each {|k| ENV.delete k }
+          ENV['http_proxy'] = 'http://127.0.0.1:8083'
+        end
+
+        include_examples "*_PROXY var (through proxy)"
+      end
+
+      ## TODO: Use a Mongrel HTTP server that can handle SSL:
+      context "with $HTTPS_PROXY env", skip: "Mongrel isn't configured to handle HTTPS, currently" do
+        let(:proxy_test_scheme) { :https }
+
+        before(:all) do
+          PROXY_ENV_VARS.each {|k| ENV.delete k }
+          ENV['HTTPS_PROXY'] = 'http://127.0.0.1:8083'
+        end
+
+        include_examples "*_PROXY var (through proxy)"
+      end
+
+      ## TODO: Use a Mongrel HTTP server that can handle SSL:
+      context "with $https_proxy env", skip: "Mongrel isn't configured to handle HTTPS, currently" do
+        let(:proxy_test_scheme) { :https }
+
+        before(:all) do
+          PROXY_ENV_VARS.each {|k| ENV.delete k }
+          ENV['https_proxy'] = 'http://127.0.0.1:8083'
+        end
+
+        include_examples "*_PROXY var (through proxy)"
+      end
+
+      context "with $ALL_PROXY env" do
+        let(:proxy_test_scheme) { :http }
+
+        before(:all) do
+          PROXY_ENV_VARS.each {|k| ENV.delete k }
+          ENV['ALL_PROXY'] = 'http://127.0.0.1:8083'
+        end
+
+        include_examples "*_PROXY var (through proxy)"
+      end
+    end
+  end
+
+  context "when parsing *_PROXY vars" do
+    context "without a *_PROXY var" do
+      before(:all) do
+        PROXY_ENV_VARS.each {|k| ENV.delete k }
+      end
+
+      subject { HttpConnectionOptions.new("http://example.com", {}) }
+      it { expect(subject.proxy_from_env).to be_nil }
+      it { expect(subject.host).to eq "example.com" }
+      it { expect(subject.port).to be 80 }
+      it { expect(subject.http_proxy?).to be_falsey }
+      it { expect(subject.connect_proxy?).to be_falsey }
+    end
+
+    context "with $HTTP_PROXY env" do
+      let(:proxy_test_scheme) { :http }
+
+      before(:each) do
+        PROXY_ENV_VARS.each {|k| ENV.delete k }
+        ENV['HTTP_PROXY'] = 'http://127.0.0.1:8083'
+      end
+
+      include_examples "*_PROXY var (testing var)"
+    end
+
+    context "with $http_proxy env" do
+      let(:proxy_test_scheme) { :http }
+
+      before(:each) do
+        PROXY_ENV_VARS.each {|k| ENV.delete k }
+        ENV['http_proxy'] = 'http://127.0.0.1:8083'
+      end
+
+      include_examples "*_PROXY var (testing var)"
+    end
+
+    context "with $HTTPS_PROXY env" do
+      let(:proxy_test_scheme) { :https }
+
+      before(:each) do
+        PROXY_ENV_VARS.each {|k| ENV.delete k }
+        ENV['HTTPS_PROXY'] = 'http://127.0.0.1:8083'
+      end
+
+      include_examples "*_PROXY var (testing var)"
+    end
+
+    context "with $https_proxy env" do
+      let(:proxy_test_scheme) { :https }
+
+      before(:each) do
+        PROXY_ENV_VARS.each {|k| ENV.delete k }
+        ENV['https_proxy'] = 'http://127.0.0.1:8083'
+      end
+
+      include_examples "*_PROXY var (testing var)"
+    end
+
+    context "with $ALL_PROXY env" do
+      let(:proxy_test_scheme) { :https }
+
+      before(:each) do
+        PROXY_ENV_VARS.each {|k| ENV.delete k }
+        ENV['ALL_PROXY'] = 'http://127.0.0.1:8083'
+      end
+
+      include_examples "*_PROXY var (testing var)"
+    end
+  end
+end