# Copyright 2015 gRPC authors.
|
#
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
# you may not use this file except in compliance with the License.
|
# You may obtain a copy of the License at
|
#
|
# http://www.apache.org/licenses/LICENSE-2.0
|
#
|
# Unless required by applicable law or agreed to in writing, software
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
# See the License for the specific language governing permissions and
|
# limitations under the License.
|
|
require 'spec_helper'
|
|
describe GRPC::Core::CompressionOptions do
|
# Note these constants should be updated
|
# according to what the core lib provides.
|
|
# Names of supported compression algorithms
|
ALGORITHMS = [:identity, :deflate, :gzip]
|
|
# Names of valid supported compression levels
|
COMPRESS_LEVELS = [:none, :low, :medium, :high]
|
|
it 'implements to_s' do
|
expect { GRPC::Core::CompressionOptions.new.to_s }.to_not raise_error
|
end
|
|
it '#to_channel_arg_hash gives the same result as #to_hash' do
|
options = GRPC::Core::CompressionOptions.new
|
expect(options.to_channel_arg_hash).to eq(options.to_hash)
|
end
|
|
# Test the normal call sequence of creating an instance
|
# and then obtaining the resulting channel-arg hash that
|
# corresponds to the compression settings of the instance
|
describe 'creating, reading, and converting to channel args hash' do
|
it 'works when no optional args were provided' do
|
options = GRPC::Core::CompressionOptions.new
|
|
ALGORITHMS.each do |algorithm|
|
expect(options.algorithm_enabled?(algorithm)).to be true
|
end
|
|
expect(options.disabled_algorithms).to be_empty
|
expect(options.default_algorithm).to be nil
|
expect(options.default_level).to be nil
|
expect(options.to_hash).to be_instance_of(Hash)
|
end
|
|
it 'works when disabling multiple algorithms' do
|
options = GRPC::Core::CompressionOptions.new(
|
default_algorithm: :identity,
|
default_level: :none,
|
disabled_algorithms: [:gzip, :deflate]
|
)
|
|
[:gzip, :deflate].each do |algorithm|
|
expect(options.algorithm_enabled?(algorithm)).to be false
|
expect(options.disabled_algorithms.include?(algorithm)).to be true
|
end
|
|
expect(options.default_algorithm).to be(:identity)
|
expect(options.default_level).to be(:none)
|
expect(options.to_hash).to be_instance_of(Hash)
|
end
|
|
it 'works when all optional args have been set' do
|
options = GRPC::Core::CompressionOptions.new(
|
default_algorithm: :gzip,
|
default_level: :low,
|
disabled_algorithms: [:deflate]
|
)
|
|
expect(options.algorithm_enabled?(:deflate)).to be false
|
expect(options.algorithm_enabled?(:gzip)).to be true
|
expect(options.disabled_algorithms).to eq([:deflate])
|
|
expect(options.default_algorithm).to be(:gzip)
|
expect(options.default_level).to be(:low)
|
expect(options.to_hash).to be_instance_of(Hash)
|
end
|
|
it 'doesnt fail when no algorithms are disabled' do
|
options = GRPC::Core::CompressionOptions.new(
|
default_algorithm: :identity,
|
default_level: :high
|
)
|
|
ALGORITHMS.each do |algorithm|
|
expect(options.algorithm_enabled?(algorithm)).to be(true)
|
end
|
|
expect(options.disabled_algorithms).to be_empty
|
expect(options.default_algorithm).to be(:identity)
|
expect(options.default_level).to be(:high)
|
expect(options.to_hash).to be_instance_of(Hash)
|
end
|
end
|
|
describe '#new with bad parameters' do
|
it 'should fail with more than one parameter' do
|
blk = proc { GRPC::Core::CompressionOptions.new(:gzip, :none) }
|
expect { blk.call }.to raise_error
|
end
|
|
it 'should fail with a non-hash parameter' do
|
blk = proc { GRPC::Core::CompressionOptions.new(:gzip) }
|
expect { blk.call }.to raise_error
|
end
|
end
|
|
describe '#default_algorithm' do
|
it 'returns nil if unset' do
|
options = GRPC::Core::CompressionOptions.new
|
expect(options.default_algorithm).to be(nil)
|
end
|
end
|
|
describe '#default_level' do
|
it 'returns nil if unset' do
|
options = GRPC::Core::CompressionOptions.new
|
expect(options.default_level).to be(nil)
|
end
|
end
|
|
describe '#disabled_algorithms' do
|
it 'returns an empty list if no algorithms were disabled' do
|
options = GRPC::Core::CompressionOptions.new
|
expect(options.disabled_algorithms).to be_empty
|
end
|
end
|
|
describe '#algorithm_enabled?' do
|
[:none, :any, 'gzip', Object.new, 1].each do |name|
|
it "should fail for parameter ${name} of class #{name.class}" do
|
options = GRPC::Core::CompressionOptions.new(
|
disabled_algorithms: [:gzip])
|
|
blk = proc do
|
options.algorithm_enabled?(name)
|
end
|
expect { blk.call }.to raise_error
|
end
|
end
|
end
|
end
|
