From 7c55ab090a952b90b79324fd163feb2bc99a0724 Mon Sep 17 00:00:00 2001 From: Alex Polcyn Date: Mon, 11 Jul 2016 23:14:32 -0700 Subject: [PATCH] removed unnecessary public methods removed tests of non api methods --- src/ruby/ext/grpc/rb_compression_options.c | 140 ++---------- src/ruby/spec/compression_options_spec.rb | 252 ++++----------------- 2 files changed, 65 insertions(+), 327 deletions(-) diff --git a/src/ruby/ext/grpc/rb_compression_options.c b/src/ruby/ext/grpc/rb_compression_options.c index 02bb3a5ddff..0a3a215b1ca 100644 --- a/src/ruby/ext/grpc/rb_compression_options.c +++ b/src/ruby/ext/grpc/rb_compression_options.c @@ -148,18 +148,9 @@ grpc_compression_level grpc_rb_compression_options_level_name_to_value_internal( rb_raise(rb_eArgError, "Unrecognized compression level name." "Valid compression level names are none, low, medium, and high."); -} - -/* Wrapper over grpc_rb_compression_options_level_name_to_value available for - * use or testing. - * Raises an exception for unrecognized level names. */ -VALUE grpc_rb_compression_options_level_name_to_value(VALUE self, - VALUE level_name) { - (void)self; - Check_Type(level_name, T_SYMBOL); - return INT2NUM((int)grpc_rb_compression_options_level_name_to_value_internal( - level_name)); + /* Dummy return statement. */ + return GRPC_COMPRESS_LEVEL_NONE; } /* Sets the default compression level, given the name of a compression level. @@ -199,18 +190,6 @@ void grpc_rb_compression_options_algorithm_name_to_value_internal( } } -/* Wrapper around algorithm_name_to_value_internal function available for use or - * testing. */ -VALUE grpc_rb_compression_options_algorithm_name_to_value( - VALUE self, VALUE algorithm_name) { - grpc_compression_algorithm algorithm_value; - (void)self; - grpc_rb_compression_options_algorithm_name_to_value_internal(&algorithm_value, - algorithm_name); - - return INT2NUM((int)algorithm_value); -} - /* Indicates whether a given algorithm is enabled on this instance, given the * readable algorithm name. */ VALUE grpc_rb_compression_options_is_algorithm_enabled(VALUE self, @@ -307,15 +286,6 @@ VALUE grpc_rb_compression_options_level_value_to_name_internal( } } -/* Wrapper of internal method that makes it available for use and testing. */ -VALUE grpc_rb_compression_options_level_value_to_name(VALUE self, - VALUE compression_value) { - (void)self; - Check_Type(compression_value, T_FIXNUM); - return grpc_rb_compression_options_level_value_to_name_internal( - (grpc_compression_level)NUM2INT(compression_value)); -} - /* Converts an algorithm internal enum value to a readable name. * Fails if the enum value is invalid. */ VALUE grpc_rb_compression_options_algorithm_value_to_name_internal( @@ -329,59 +299,21 @@ VALUE grpc_rb_compression_options_algorithm_value_to_name_internal( return ID2SYM(rb_intern(algorithm_name)); } -/* Wrapper of algorithm_to_name internal function available for ues and testing. - */ -VALUE grpc_rb_compression_options_algorithm_value_to_name( - VALUE self, VALUE algorithm_value) { - grpc_compression_algorithm algorithm_internal_value = - (grpc_compression_algorithm)NUM2INT(algorithm_value); - (void)self; - - return grpc_rb_compression_options_algorithm_value_to_name_internal( - algorithm_internal_value); -} - -/* Gets the internal value of the default compression level that is to be passed - * to the GRPC core as a channel argument value. - * A nil return value means that it hasn't been set. */ -VALUE grpc_rb_compression_options_get_default_algorithm_internal_value( - VALUE self) { - grpc_rb_compression_options *wrapper = NULL; - - TypedData_Get_Struct(self, grpc_rb_compression_options, - &grpc_rb_compression_options_data_type, wrapper); - - if (wrapper->wrapped->default_algorithm.is_set) { - return INT2NUM(wrapper->wrapped->default_algorithm.algorithm); - } - return Qnil; -} - /* Gets the readable name of the default algorithm if one has been set. * Returns nil if no algorithm has been set. */ VALUE grpc_rb_compression_options_get_default_algorithm(VALUE self) { - VALUE algorithm_value = - grpc_rb_compression_options_get_default_algorithm_internal_value(self); - - if (RTEST(algorithm_value)) { - return grpc_rb_compression_options_algorithm_value_to_name(self, - algorithm_value); - } - - return Qnil; -} - -/* Gets the internal enum value of the default algorithm if one has been set. - * Returns nil if no default algorithm has been set. */ -VALUE grpc_rb_compression_options_get_default_level_internal_value(VALUE self) { + grpc_compression_algorithm internal_value; grpc_rb_compression_options *wrapper = NULL; TypedData_Get_Struct(self, grpc_rb_compression_options, &grpc_rb_compression_options_data_type, wrapper); - if (wrapper->wrapped->default_level.is_set) { - return INT2NUM((int)wrapper->wrapped->default_level.level); + if (wrapper->wrapped->default_algorithm.is_set) { + internal_value = wrapper->wrapped->default_algorithm.algorithm; + return grpc_rb_compression_options_algorithm_value_to_name_internal( + internal_value); } + return Qnil; } @@ -390,11 +322,13 @@ VALUE grpc_rb_compression_options_get_default_level_internal_value(VALUE self) { * A nil return value means that it hasn't been set. */ VALUE grpc_rb_compression_options_get_default_level(VALUE self) { grpc_compression_level internal_value; - VALUE ruby_value = - grpc_rb_compression_options_get_default_level_internal_value(self); + grpc_rb_compression_options *wrapper = NULL; + + TypedData_Get_Struct(self, grpc_rb_compression_options, + &grpc_rb_compression_options_data_type, wrapper); - if (RTEST(ruby_value)) { - internal_value = (grpc_compression_level)NUM2INT(ruby_value); + if (wrapper->wrapped->default_level.is_set) { + internal_value = wrapper->wrapped->default_level.level; return grpc_rb_compression_options_level_value_to_name_internal( internal_value); } @@ -403,7 +337,7 @@ VALUE grpc_rb_compression_options_get_default_level(VALUE self) { } /* Gets a list of the disabled algorithms as readable names. - * Returns an empty list of no algorithms have been disabled. */ + * Returns an empty list if no algorithms have been disabled. */ VALUE grpc_rb_compression_options_get_disabled_algorithms(VALUE self) { VALUE disabled_algorithms = rb_ary_new(); grpc_compression_algorithm internal_value; @@ -424,16 +358,6 @@ VALUE grpc_rb_compression_options_get_disabled_algorithms(VALUE self) { return disabled_algorithms; } -/* Provides a bitset as a ruby number that is suitable to pass to - * the GRPC core as a channel argument to enable compression algorithms. */ -VALUE grpc_rb_compression_options_get_enabled_algorithms_bitset(VALUE self) { - grpc_rb_compression_options *wrapper = NULL; - - TypedData_Get_Struct(self, grpc_rb_compression_options, - &grpc_rb_compression_options_data_type, wrapper); - return INT2NUM((int)wrapper->wrapped->enabled_algorithms_bitset); -} - /* Initializes the compression options wrapper. * Takes an optional hash parameter. * @@ -511,11 +435,6 @@ void Init_grpc_compression_options() { rb_define_method(grpc_rb_cCompressionOptions, "initialize", grpc_rb_compression_options_init, -1); - /* Gets the bitset of enabled algorithms. */ - rb_define_method(grpc_rb_cCompressionOptions, "enabled_algorithms_bitset", - grpc_rb_compression_options_get_enabled_algorithms_bitset, - 0); - /* Methods for getting the default algorithm, default level, and disabled * algorithms as readable names. */ rb_define_method(grpc_rb_cCompressionOptions, "default_algorithm", @@ -525,38 +444,11 @@ void Init_grpc_compression_options() { rb_define_method(grpc_rb_cCompressionOptions, "disabled_algorithms", grpc_rb_compression_options_get_disabled_algorithms, 0); - /* Methods for getting the internal enum default algorithm and level enum - * values of an instance. */ - rb_define_method( - grpc_rb_cCompressionOptions, "default_algorithm_internal_value", - grpc_rb_compression_options_get_default_algorithm_internal_value, 0); - rb_define_method(grpc_rb_cCompressionOptions, "default_level_internal_value", - grpc_rb_compression_options_get_default_level_internal_value, - 0); - /* Determines whether or not an algorithm is enabled, given a readable * algorithm name.*/ - rb_define_method(grpc_rb_cCompressionOptions, "is_algorithm_enabled", + rb_define_method(grpc_rb_cCompressionOptions, "algorithm_enabled?", grpc_rb_compression_options_is_algorithm_enabled, 1); - /* Methods for converting to and from algorithm enum values and their readable - * names. */ - rb_define_singleton_method( - grpc_rb_cCompressionOptions, "algorithm_name_to_value", - grpc_rb_compression_options_algorithm_name_to_value, 1); - rb_define_singleton_method( - grpc_rb_cCompressionOptions, "algorithm_value_to_name", - grpc_rb_compression_options_algorithm_value_to_name, 1); - - /* Methods for converting to and from compression level enum values and their - * readable names. */ - rb_define_singleton_method(grpc_rb_cCompressionOptions, "level_name_to_value", - grpc_rb_compression_options_level_name_to_value, - 1); - rb_define_singleton_method(grpc_rb_cCompressionOptions, "level_value_to_name", - grpc_rb_compression_options_level_value_to_name, - 1); - /* Provides a hash of the compression settings suitable * for passing to server or channel args. */ rb_define_method(grpc_rb_cCompressionOptions, "to_hash", diff --git a/src/ruby/spec/compression_options_spec.rb b/src/ruby/spec/compression_options_spec.rb index 7fa416ef095..dbd7e592947 100644 --- a/src/ruby/spec/compression_options_spec.rb +++ b/src/ruby/spec/compression_options_spec.rb @@ -30,30 +30,14 @@ require 'grpc' describe GRPC::Core::CompressionOptions do - # Note these constants should be updated according to what the core lib does. + # Note these constants should be updated + # according to what the core lib provides. - # Names of supported compression algorithms and their internal enum values - ALGORITHMS = { - identity: 0, - deflate: 1, - gzip: 2 - } + # Names of supported compression algorithms + ALGORITHMS = [:identity, :deflate, :gzip] - # Compression algorithms and their corresponding bits in the internal - # enabled algorithms bitset for GRPC core channel args. - ALGORITHM_BITS = { - identity: 0x1, - deflate: 0x2, - gzip: 0x4 - } - - # Names of valid supported compression levels and their internal enum values - COMPRESS_LEVELS = { - none: 0, - low: 1, - medium: 2, - high: 3 - } + # 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 @@ -61,70 +45,73 @@ describe GRPC::Core::CompressionOptions do 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 eql(options.to_hash) + 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 and converting to channel args hash' do - it 'gives the correct channel args when nothing has been adjusted yet' do - expect(GRPC::Core::CompressionOptions.new.to_hash).to( - eql('grpc.compression_enabled_algorithms_bitset' => 0x7)) + 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 'gives the correct channel args after disabling multiple algorithms' do + it 'works when disabling multiple algorithms' do options = GRPC::Core::CompressionOptions.new( default_algorithm: :identity, default_level: :none, disabled_algorithms: [:gzip, :deflate] ) - channel_arg_hash = options.to_hash - expect(channel_arg_hash['grpc.default_compression_algorithm']).to eq(0) - expect(channel_arg_hash['grpc.default_compression_level']).to eq(0) + [:gzip, :deflate].each do |algorithm| + expect(options.algorithm_enabled?(algorithm)).to be false + expect(options.disabled_algorithms.include?(algorithm)).to be true + end - bitset = channel_arg_hash['grpc.compression_enabled_algorithms_bitset'] - expect(bitset & ALGORITHM_BITS[:gzip]).to eq(0) - expect(bitset & ALGORITHM_BITS[:deflate]).to eq(0) + 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 'gives correct channel args with all args set' do + it 'works when all optional args have been set' do options = GRPC::Core::CompressionOptions.new( default_algorithm: :gzip, default_level: :low, disabled_algorithms: [:deflate] ) - channel_arg_hash = options.to_hash - - actual_bitset = channel_arg_hash[ - 'grpc.compression_enabled_algorithms_bitset'] - default_algorithm = channel_arg_hash['grpc.default_compression_algorithm'] - default_level = channel_arg_hash['grpc.default_compression_level'] + expect(options.algorithm_enabled?(:deflate)).to be false + expect(options.algorithm_enabled?(:gzip)).to be true + expect(options.disabled_algorithms).to eq([:deflate]) - expect(actual_bitset & ALGORITHM_BITS[:deflate]).to eq(0) - expect(default_algorithm).to eq(ALGORITHMS[:gzip]) - expect(default_level).to eq(COMPRESS_LEVELS[:low]) + 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 'gives correct channel args when no algorithms are disabled' do + it 'doesnt fail when no algorithms are disabled' do options = GRPC::Core::CompressionOptions.new( default_algorithm: :identity, default_level: :high ) - channel_arg_hash = options.to_hash - - actual_bitset = channel_arg_hash[ - 'grpc.compression_enabled_algorithms_bitset'] - default_algorithm = channel_arg_hash['grpc.default_compression_algorithm'] - default_level = channel_arg_hash['grpc.default_compression_level'] + ALGORITHMS.each do |algorithm| + expect(options.algorithm_enabled?(algorithm)).to be(true) + end - expect(actual_bitset & ALGORITHM_BITS[:deflate]).to_not eq(0) - expect(actual_bitset & ALGORITHM_BITS[:gzip]).to_not eq(0) - expect(default_algorithm).to eq(ALGORITHMS[:identity]) - expect(default_level).to eq(COMPRESS_LEVELS[:high]) + 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 @@ -140,179 +127,38 @@ describe GRPC::Core::CompressionOptions do end end - describe '#level_name_to_value' do - COMPRESS_LEVELS.each_pair do |name, internal_value| - it "should return value #{internal_value} for level #{name}" do - actual_value = GRPC::Core::CompressionOptions.level_name_to_value(name) - expect(actual_value).to eq(internal_value) - end - end - - [:gzip, :deflate, :any, Object.new, 'none', 'low', 1].each do |name| - it "should fail for parameter #{name} of class #{name.class}" do - blk = proc do - GRPC::Core::CompressionOptions.level_name_to_value(name) - end - expect { blk.call }.to raise_error - end - end - end - - describe '#level_value_to_name' do - COMPRESS_LEVELS.each_pair do |name, internal_value| - it "should return level name #{name} for value #{internal_value}" do - actual_name = GRPC::Core::CompressionOptions.level_value_to_name( - internal_value) - expect(actual_name).to eq(name) - end - end - it 'should give the correct internal values from compression level names' do - cls = GRPC::Core::CompressionOptions - COMPRESS_LEVELS.each_pair do |name, internal_value| - expect(cls.level_value_to_name(internal_value)).to eq(name) - end - end - - [:gzip, :any, Object.new, '1', :low].each do |name| - it "should fail for parameter #{name} of class #{name.class}" do - blk = proc do - GRPC::Core::CompressionOptions.level_value_to_name(name) - end - expect { blk.call }.to raise_error - end - end - end - - describe '#algorithm_name_to_value' do - it 'should give the correct internal values from algorithm names' do - cls = GRPC::Core::CompressionOptions - ALGORITHMS.each_pair do |name, internal_value| - expect(cls.algorithm_name_to_value(name)).to eq(internal_value) - end - end - - ['gzip', 'deflate', :any, Object.new, :none, :low, 1].each do |name| - it "should fail for parameter #{name} of class #{name.class}" do - blk = proc do - GRPC::Core::CompressionOptions.algorithm_name_to_value(name) - end - expect { blk.call }.to raise_error - end - end - end - - describe '#algorithm_value_to_name' do - it 'should give the correct internal values from algorithm names' do - cls = GRPC::Core::CompressionOptions - ALGORITHMS.each_pair do |name, internal_value| - expect(cls.algorithm_value_to_name(internal_value)).to eq(name) - end - end - - ['gzip', :deflate, :any, Object.new, :low, '1'].each do |value| - it "should fail for parameter #{value} of class #{value.class}" do - blk = proc do - GRPC::Core::CompressionOptions.algorithm_value_to_name(value) - end - expect { blk.call }.to raise_error - end - end - end - - describe '#default_algorithm and #default_algorithm_internal_value' do - it 'can set the default algorithm and then read it back out' do - ALGORITHMS.each_pair do |name, internal_value| - options = GRPC::Core::CompressionOptions.new(default_algorithm: name) - expect(options.default_algorithm).to eq(name) - expect(options.default_algorithm_internal_value).to eq(internal_value) - end - end - + describe '#default_algorithm' do it 'returns nil if unset' do options = GRPC::Core::CompressionOptions.new - expect(options.default_algorithm).to be_nil - expect(options.default_algorithm_internal_value).to be_nil + expect(options.default_algorithm).to be(nil) end end - describe '#default_level and #default_level_internal_value' do - it 'can set the default level and read it back out' do - COMPRESS_LEVELS.each_pair do |name, internal_value| - options = GRPC::Core::CompressionOptions.new(default_level: name) - expect(options.default_level).to eq(name) - expect(options.default_level_internal_value).to eq(internal_value) - end - end - + describe '#default_level' do it 'returns nil if unset' do options = GRPC::Core::CompressionOptions.new - expect(options.default_level).to be_nil - expect(options.default_level_internal_value).to be_nil + expect(options.default_level).to be(nil) end end describe '#disabled_algorithms' do - it 'can set the disabled algorithms and read them back out' do - options = GRPC::Core::CompressionOptions.new( - disabled_algorithms: [:gzip, :deflate]) - - [:gzip, :deflate].each do |name| - expect(options.disabled_algorithms.include?(name)).to eq(true) - end - expect(options.disabled_algorithms.size).to eq(2) - end - it 'returns an empty list if no algorithms were disabled' do options = GRPC::Core::CompressionOptions.new - expect(options.disabled_algorithms).to eq([]) + expect(options.disabled_algorithms).to be_empty end end - describe '#is_algorithm_enabled' do - it 'returns true if the algorithm is valid and not disabled' do - options = GRPC::Core::CompressionOptions.new(disabled_algorithms: [:gzip]) - expect(options.is_algorithm_enabled(:deflate)).to eq(true) - end - - it 'returns false if the algorithm is valid and disabled' do - options = GRPC::Core::CompressionOptions.new(disabled_algorithms: [:gzip]) - expect(options.is_algorithm_enabled(:gzip)).to eq(false) - 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.is_algorithm_enabled(name) + options.algorithm_enabled?(name) end expect { blk.call }.to raise_error end end end - - describe '#enabled_algoritms_bitset' do - it 'should respond to not disabling any algorithms' do - options = GRPC::Core::CompressionOptions.new - actual_bitset = options.enabled_algorithms_bitset - expect(actual_bitset & ALGORITHM_BITS[:gzip]).to_not eq(0) - expect(actual_bitset & ALGORITHM_BITS[:deflate]).to_not eq(0) - end - - it 'should respond to disabling one algorithm' do - options = GRPC::Core::CompressionOptions.new( - disabled_algorithms: [:gzip]) - expect(options.enabled_algorithms_bitset & ALGORITHM_BITS[:gzip]).to eq(0) - end - - it 'should respond to disabling multiple algorithms' do - options = GRPC::Core::CompressionOptions.new( - disabled_algorithms: [:gzip, :deflate]) - - actual_bitset = options.enabled_algorithms_bitset - expect(actual_bitset & ALGORITHM_BITS[:gzip]).to eq(0) - expect(actual_bitset & ALGORITHM_BITS[:deflate]).to eq(0) - end - end end