ceph/src/jaegertracing/thrift/lib/rb/spec/server_spec.rb

   1 #
   2 # Licensed to the Apache Software Foundation (ASF) under one
   3 # or more contributor license agreements. See the NOTICE file
   4 # distributed with this work for additional information
   5 # regarding copyright ownership. The ASF licenses this file
   6 # to you under the Apache License, Version 2.0 (the
   7 # "License"); you may not use this file except in compliance
   8 # with the License. You may obtain a copy of the License at
   9 #
  10 #   http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 # Unless required by applicable law or agreed to in writing,
  13 # software distributed under the License is distributed on an
  14 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  15 # KIND, either express or implied. See the License for the
  16 # specific language governing permissions and limitations
  17 # under the License.
  18 #
  19 require 'spec_helper'
  20
  21 describe 'Server' do
  22
  23   describe Thrift::BaseServer do
  24     before(:each) do
  25       @processor = double("Processor")
  26       @serverTrans = double("ServerTransport")
  27       @trans = double("BaseTransport")
  28       @prot = double("BaseProtocol")
  29       @server = described_class.new(@processor, @serverTrans, @trans, @prot)
  30     end
  31
  32     it "should default to BaseTransportFactory and BinaryProtocolFactory when not specified" do
  33       @server = Thrift::BaseServer.new(double("Processor"), double("BaseServerTransport"))
  34       expect(@server.instance_variable_get(:'@transport_factory')).to be_an_instance_of(Thrift::BaseTransportFactory)
  35       expect(@server.instance_variable_get(:'@protocol_factory')).to be_an_instance_of(Thrift::BinaryProtocolFactory)
  36     end
  37
  38     it "should not serve" do
  39       expect { @server.serve()}.to raise_error(NotImplementedError)
  40     end
  41
  42     it "should provide a reasonable to_s" do
  43       expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
  44       expect(@trans).to receive(:to_s).once.and_return("trans")
  45       expect(@prot).to receive(:to_s).once.and_return("prot")
  46       expect(@server.to_s).to eq("server(prot(trans(serverTrans)))")
  47     end
  48   end
  49
  50   describe Thrift::SimpleServer do
  51     before(:each) do
  52       @processor = double("Processor")
  53       @serverTrans = double("ServerTransport")
  54       @trans = double("BaseTransport")
  55       @prot = double("BaseProtocol")
  56       @client = double("Client")
  57       @server = described_class.new(@processor, @serverTrans, @trans, @prot)
  58     end
  59
  60     it "should provide a reasonable to_s" do
  61       expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
  62       expect(@trans).to receive(:to_s).once.and_return("trans")
  63       expect(@prot).to receive(:to_s).once.and_return("prot")
  64       expect(@server.to_s).to eq("simple(server(prot(trans(serverTrans))))")
  65     end
  66
  67     it "should serve in the main thread" do
  68       expect(@serverTrans).to receive(:listen).ordered
  69       expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
  70       expect(@trans).to receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
  71       expect(@prot).to receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
  72       x = 0
  73       expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
  74         case (x += 1)
  75         when 1 then raise Thrift::TransportException
  76         when 2 then raise Thrift::ProtocolException
  77         when 3 then throw :stop
  78         end
  79       end
  80       expect(@trans).to receive(:close).exactly(3).times
  81       expect(@serverTrans).to receive(:close).ordered
  82       expect { @server.serve }.to throw_symbol(:stop)
  83     end
  84   end
  85
  86   describe Thrift::ThreadedServer do
  87     before(:each) do
  88       @processor = double("Processor")
  89       @serverTrans = double("ServerTransport")
  90       @trans = double("BaseTransport")
  91       @prot = double("BaseProtocol")
  92       @client = double("Client")
  93       @server = described_class.new(@processor, @serverTrans, @trans, @prot)
  94     end
  95
  96     it "should provide a reasonable to_s" do
  97       expect(@serverTrans).to receive(:to_s).once.and_return("serverTrans")
  98       expect(@trans).to receive(:to_s).once.and_return("trans")
  99       expect(@prot).to receive(:to_s).once.and_return("prot")
 100       expect(@server.to_s).to eq("threaded(server(prot(trans(serverTrans))))")
 101     end
 102
 103     it "should serve using threads" do
 104       expect(@serverTrans).to receive(:listen).ordered
 105       expect(@serverTrans).to receive(:accept).exactly(3).times.and_return(@client)
 106       expect(@trans).to receive(:get_transport).exactly(3).times.with(@client).and_return(@trans)
 107       expect(@prot).to receive(:get_protocol).exactly(3).times.with(@trans).and_return(@prot)
 108       expect(Thread).to receive(:new).with(@prot, @trans).exactly(3).times.and_yield(@prot, @trans)
 109       x = 0
 110       expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
 111         case (x += 1)
 112         when 1 then raise Thrift::TransportException
 113         when 2 then raise Thrift::ProtocolException
 114         when 3 then throw :stop
 115         end
 116       end
 117       expect(@trans).to receive(:close).exactly(3).times
 118       expect(@serverTrans).to receive(:close).ordered
 119       expect { @server.serve }.to throw_symbol(:stop)
 120     end
 121   end
 122
 123   describe Thrift::ThreadPoolServer do
 124     before(:each) do
 125       @processor = double("Processor")
 126       @server_trans = double("ServerTransport")
 127       @trans = double("BaseTransport")
 128       @prot = double("BaseProtocol")
 129       @client = double("Client")
 130       @server = described_class.new(@processor, @server_trans, @trans, @prot)
 131       sleep(0.15)
 132     end
 133
 134     it "should provide a reasonable to_s" do
 135       expect(@server_trans).to receive(:to_s).once.and_return("server_trans")
 136       expect(@trans).to receive(:to_s).once.and_return("trans")
 137       expect(@prot).to receive(:to_s).once.and_return("prot")
 138       expect(@server.to_s).to eq("threadpool(server(prot(trans(server_trans))))")
 139     end
 140
 141     it "should serve inside a thread" do
 142       exception_q = @server.instance_variable_get(:@exception_q)
 143       expect_any_instance_of(described_class).to receive(:serve) do
 144         exception_q.push(StandardError.new('ERROR'))
 145       end
 146       expect { @server.rescuable_serve }.to(raise_error('ERROR'))
 147       sleep(0.15)
 148     end
 149
 150     it "should avoid running the server twice when retrying rescuable_serve" do
 151       exception_q = @server.instance_variable_get(:@exception_q)
 152       expect_any_instance_of(described_class).to receive(:serve) do
 153         exception_q.push(StandardError.new('ERROR1'))
 154         exception_q.push(StandardError.new('ERROR2'))
 155       end
 156       expect { @server.rescuable_serve }.to(raise_error('ERROR1'))
 157       expect { @server.rescuable_serve }.to(raise_error('ERROR2'))
 158     end
 159
 160     it "should serve using a thread pool" do
 161       thread_q = double("SizedQueue")
 162       exception_q = double("Queue")
 163       @server.instance_variable_set(:@thread_q, thread_q)
 164       @server.instance_variable_set(:@exception_q, exception_q)
 165       expect(@server_trans).to receive(:listen).ordered
 166       expect(thread_q).to receive(:push).with(:token)
 167       expect(thread_q).to receive(:pop)
 168       expect(Thread).to receive(:new).and_yield
 169       expect(@server_trans).to receive(:accept).exactly(3).times.and_return(@client)
 170       expect(@trans).to receive(:get_transport).exactly(3).times.and_return(@trans)
 171       expect(@prot).to receive(:get_protocol).exactly(3).times.and_return(@prot)
 172       x = 0
 173       error = RuntimeError.new("Stopped")
 174       expect(@processor).to receive(:process).exactly(3).times.with(@prot, @prot) do
 175         case (x += 1)
 176         when 1 then raise Thrift::TransportException
 177         when 2 then raise Thrift::ProtocolException
 178         when 3 then raise error
 179         end
 180       end
 181       expect(@trans).to receive(:close).exactly(3).times
 182       expect(exception_q).to receive(:push).with(error).and_throw(:stop)
 183       expect(@server_trans).to receive(:close)
 184       expect { @server.serve }.to(throw_symbol(:stop))
 185     end
 186   end
 187 end