Bump rubocop

also apply new rules

.codeclimate.yml

@@ -2,7 +2,7 @@
 engines:
   rubocop:
     enabled: true
-    channel: rubocop-1-10-0
+    channel: rubocop-1-22-3
   bundler-audit:
     enabled: true
 ratings:

.rubocop.yml

@@ -12,7 +12,7 @@ Rails:
   Enabled: true
 
 # Commonly used screens these days easily fit more than 80 characters.
-Metrics/LineLength:
+Layout/LineLength:
   Max: 120
 
 # Too short methods lead to extraction of single-use methods, which can make

Gemfile

@@ -21,8 +21,8 @@ group :development do
   # code style
   gem "pronto",         "0.11.0",  require: false
   gem "pronto-rubocop", "0.11.1",  require: false
-  gem "rubocop",        "1.18.0",  require: false
+  gem "rubocop",        "1.23.0",  require: false
-  gem "rubocop-rails",  "2.11.1",  require: false
+  gem "rubocop-rails",  "2.12.4",  require: false
 
   # debugging
   gem "pry"

Gemfile.lock

@@ -117,8 +117,8 @@ GEM
     octokit (4.21.0)
       faraday (>= 0.9)
       sawyer (~> 0.8.0, >= 0.5.3)
-    parallel (1.20.1)
+    parallel (1.21.0)
-    parser (3.0.1.1)
+    parser (3.0.3.0)
       ast (~> 2.4.1)
     pronto (0.11.0)
       gitlab (~> 4.4, >= 4.4.0)
@@ -184,18 +184,18 @@ GEM
       rspec-mocks (~> 3.10)
       rspec-support (~> 3.10)
     rspec-support (3.10.2)
-    rubocop (1.18.0)
+    rubocop (1.23.0)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 1.12.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.7.0)
+    rubocop-ast (1.13.0)
       parser (>= 3.0.1.1)
-    rubocop-rails (2.11.1)
+    rubocop-rails (2.12.4)
       activesupport (>= 4.2.0)
       rack (>= 1.1)
       rubocop (>= 1.7.0, < 2.0)
@@ -221,7 +221,7 @@ GEM
       ethon (>= 0.9.0)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (1.7.0)
+    unicode-display_width (1.8.0)
     uuid (2.3.9)
       macaddr (~> 1.0)
     valid (1.2.0)
@@ -253,8 +253,8 @@ DEPENDENCIES
   rspec-collection_matchers (~> 1.2.0)
   rspec-json_expectations (~> 2.1)
   rspec-rails (~> 5.0.1)
-  rubocop (= 1.18.0)
+  rubocop (= 1.23.0)
-  rubocop-rails (= 2.11.1)
+  rubocop-rails (= 2.12.4)
   simplecov (= 0.21.2)
   simplecov-rcov (= 0.2.3)
   webmock (~> 3.0)

lib/diaspora_federation/entities/relayable.rb

@@ -95,9 +95,9 @@ module DiasporaFederation
       # The order for signing
       # @return [Array]
       def signature_order
-        @signature_order || self.class.class_props.keys.reject {|key|
+        @signature_order || (self.class.class_props.keys.reject {|key|
           self.class.optional_props.include?(key) && public_send(key).nil?
-        } - %i[author_signature parent]
+        } - %i[author_signature parent])
       end
 
       private
@@ -136,7 +136,7 @@ module DiasporaFederation
 
       def signature_order=(order)
         prop_names = self.class.class_props.keys.map(&:to_s)
-        @signature_order = order.reject {|name| name =~ /signature/ }
+        @signature_order = order.grep_v(/signature/)
                                 .map {|name| prop_names.include?(name) ? name.to_sym : name }
       end
 

lib/diaspora_federation/entity.rb

@@ -215,7 +215,7 @@ module DiasporaFederation
     end
 
     def setable_property?(type, val)
-      setable_string?(type, val) || type == :timestamp && val.is_a?(Time)
+      setable_string?(type, val) || (type == :timestamp && val.is_a?(Time))
     end
 
     def setable_string?(type, val)

spec/lib/diaspora_federation/entity_spec.rb

@@ -61,7 +61,7 @@ module DiasporaFederation
         expect(entity.test1).to be_nil
       end
 
-      context "validation" do
+      context "when validating" do
         let(:invalid_data) { {test1: "as;df", test2: nil, test3: "no boolean"} }
 
         it "validates the entity and raise an error with failed properties if not valid" do

spec/lib/diaspora_federation/validators/optional_aware_validator_spec.rb

@@ -42,7 +42,7 @@ module DiasporaFederation
     end
 
     it "doesn't fail when the entity doesn't have optional props" do
-      entity = OpenStruct.new(test1: nil)
+      entity = Struct.new(:test1).new(nil)
       validator = Validators::TestUnknownEntityValidator.new(entity)
       expect(validator).not_to be_valid
       expect(validator.errors).to include(:test1)

spec/lib/diaspora_federation/validators/rules/birthday_spec.rb

@@ -12,9 +12,13 @@ describe Validation::Rule::Birthday do
     expect(described_class.new.error_key).to eq(:birthday)
   end
 
-  context "validation" do
+  context "when validating" do
+    before do
+      stub_const("BirthdayHolder", Struct.new(:birthday))
+    end
+
     it "validates a date object" do
-      validator = Validation::Validator.new(OpenStruct.new(birthday: Date.new))
+      validator = Validation::Validator.new(BirthdayHolder.new(Date.new))
       validator.rule(:birthday, :birthday)
 
       expect(validator).to be_valid
@@ -22,7 +26,7 @@ describe Validation::Rule::Birthday do
     end
 
     it "validates a string" do
-      validator = Validation::Validator.new(OpenStruct.new(birthday: "2015-07-19"))
+      validator = Validation::Validator.new(BirthdayHolder.new("2015-07-19"))
       validator.rule(:birthday, :birthday)
 
       expect(validator).to be_valid
@@ -31,7 +35,7 @@ describe Validation::Rule::Birthday do
 
     it "allows nil and empty" do
       [nil, ""].each do |val|
-        validator = Validation::Validator.new(OpenStruct.new(birthday: val))
+        validator = Validation::Validator.new(BirthdayHolder.new(val))
         validator.rule(:birthday, :birthday)
 
         expect(validator).to be_valid
@@ -40,7 +44,7 @@ describe Validation::Rule::Birthday do
     end
 
     it "fails for invalid date string" do
-      validator = Validation::Validator.new(OpenStruct.new(birthday: "i'm no date"))
+      validator = Validation::Validator.new(BirthdayHolder.new("i'm no date"))
       validator.rule(:birthday, :birthday)
 
       expect(validator).not_to be_valid

spec/lib/diaspora_federation/validators/rules/boolean_spec.rb

@@ -4,7 +4,7 @@ describe Validation::Rule::Boolean do
   it "will not accept parameters" do
     validator = Validation::Validator.new({})
     expect {
-      validator.rule(:number, numeric: {param: true})
+      validator.rule(:boolean, boolean: {param: true})
     }.to raise_error ArgumentError
   end
 
@@ -12,11 +12,15 @@ describe Validation::Rule::Boolean do
     expect(described_class.new.error_key).to eq(:boolean)
   end
 
-  context "validation" do
+  context "when validating" do
+    before do
+      stub_const("BooleanHolder", Struct.new(:boolean))
+    end
+
     context "strings" do
       it "validates boolean-esque strings" do
         %w[true false yes no t f y n 1 0].each do |str|
-          validator = Validation::Validator.new(OpenStruct.new(boolean: str))
+          validator = Validation::Validator.new(BooleanHolder.new(str))
           validator.rule(:boolean, :boolean)
 
           expect(validator).to be_valid
@@ -25,7 +29,7 @@ describe Validation::Rule::Boolean do
       end
 
       it "fails for non-boolean-esque strings" do
-        validator = Validation::Validator.new(OpenStruct.new(boolean: "asdf"))
+        validator = Validation::Validator.new(BooleanHolder.new("asdf"))
         validator.rule(:boolean, :boolean)
 
         expect(validator).not_to be_valid
@@ -36,7 +40,7 @@ describe Validation::Rule::Boolean do
     context "numbers" do
       it "validates 0 and 1 to boolean" do
         [0, 1].each do |num|
-          validator = Validation::Validator.new(OpenStruct.new(boolean: num))
+          validator = Validation::Validator.new(BooleanHolder.new(num))
           validator.rule(:boolean, :boolean)
 
           expect(validator).to be_valid
@@ -45,7 +49,7 @@ describe Validation::Rule::Boolean do
       end
 
       it "fails for all other numbers" do
-        validator = Validation::Validator.new(OpenStruct.new(boolean: 1234))
+        validator = Validation::Validator.new(BooleanHolder.new(1234))
         validator.rule(:boolean, :boolean)
 
         expect(validator).not_to be_valid
@@ -56,7 +60,7 @@ describe Validation::Rule::Boolean do
     context "boolean types" do
       it "validates true and false" do
         [true, false].each do |bln|
-          validator = Validation::Validator.new(OpenStruct.new(boolean: bln))
+          validator = Validation::Validator.new(BooleanHolder.new(bln))
           validator.rule(:boolean, :boolean)
 
           expect(validator).to be_valid
@@ -67,7 +71,7 @@ describe Validation::Rule::Boolean do
 
     it "fails if nil or empty" do
       [nil, ""].each do |val|
-        validator = Validation::Validator.new(OpenStruct.new(boolean: val))
+        validator = Validation::Validator.new(BooleanHolder.new(val))
         validator.rule(:boolean, :boolean)
 
         expect(validator).not_to be_valid

spec/lib/diaspora_federation/validators/rules/diaspora_id_list_spec.rb

@@ -39,9 +39,13 @@ describe Validation::Rule::DiasporaIdList do
     expect(described_class.new(maximum: 5).error_key).to eq(:diaspora_id_list)
   end
 
-  context "validation" do
+  context "when validating" do
+    before do
+      stub_const("DiasporaIdsHolder", Struct.new(:ids))
+    end
+
     it "validates less ids" do
-      validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      validator = Validation::Validator.new(DiasporaIdsHolder.new(id_str))
       validator.rule(:ids, diaspora_id_list: {maximum: 5})
 
       expect(validator).to be_valid
@@ -50,7 +54,7 @@ describe Validation::Rule::DiasporaIdList do
 
     it "fails for less but non ids" do
       bad_str = "user@example.com;i am a weird diaspora* ID @@@ ### 12345;shouldnt be reached by a rule"
-      validator = Validation::Validator.new(OpenStruct.new(ids: bad_str))
+      validator = Validation::Validator.new(DiasporaIdsHolder.new(bad_str))
       validator.rule(:ids, diaspora_id_list: {maximum: 5})
 
       expect(validator).not_to be_valid
@@ -58,7 +62,7 @@ describe Validation::Rule::DiasporaIdList do
     end
 
     it "validates exactly as many ids" do
-      validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      validator = Validation::Validator.new(DiasporaIdsHolder.new(id_str))
       validator.rule(:ids, diaspora_id_list: {minimum: 3, maximum: 3})
 
       expect(validator).to be_valid
@@ -66,7 +70,7 @@ describe Validation::Rule::DiasporaIdList do
     end
 
     it "validates without params" do
-      validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      validator = Validation::Validator.new(DiasporaIdsHolder.new(id_str))
       validator.rule(:ids, :diaspora_id_list)
 
       expect(validator).to be_valid
@@ -74,7 +78,7 @@ describe Validation::Rule::DiasporaIdList do
     end
 
     it "fails for too many ids" do
-      validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      validator = Validation::Validator.new(DiasporaIdsHolder.new(id_str))
       validator.rule(:ids, diaspora_id_list: {maximum: 2})
 
       expect(validator).not_to be_valid
@@ -82,7 +86,7 @@ describe Validation::Rule::DiasporaIdList do
     end
 
     it "fails for too less ids" do
-      validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      validator = Validation::Validator.new(DiasporaIdsHolder.new(id_str))
       validator.rule(:ids, diaspora_id_list: {minimum: 4})
 
       expect(validator).not_to be_valid

spec/lib/diaspora_federation/validators/rules/diaspora_id_spec.rb

@@ -12,9 +12,13 @@ describe Validation::Rule::DiasporaId do
     expect(described_class.new.error_key).to eq(:diaspora_id)
   end
 
-  context "validation" do
+  context "when validating" do
+    before do
+      stub_const("DiasporaIdHolder", Struct.new(:diaspora_id))
+    end
+
     it "validates a normal diaspora* ID" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user@example.com"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user@example.com"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).to be_valid
@@ -22,7 +26,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "validates a diaspora* ID with localhost" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user@localhost"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user@localhost"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).to be_valid
@@ -30,7 +34,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "validates a diaspora* ID with port" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user@example.com:3000"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user@example.com:3000"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).to be_valid
@@ -38,7 +42,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "validates a diaspora* ID with IPv4 address" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user@123.45.67.89"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user@123.45.67.89"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).to be_valid
@@ -46,7 +50,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "validates a diaspora* ID with IPv6 address" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user@[2001:1234:5678:90ab:cdef::1]"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user@[2001:1234:5678:90ab:cdef::1]"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).to be_valid
@@ -54,7 +58,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "validates a diaspora* ID with . and -" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some-fancy.user@example.com"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some-fancy.user@example.com"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).to be_valid
@@ -62,7 +66,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "fails if the diaspora* ID contains a / in the domain-name" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user@example.com/friendica"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user@example.com/friendica"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).not_to be_valid
@@ -70,7 +74,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "fails if the diaspora* ID contains a _ in the domain-name" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user@invalid_domain.com"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user@invalid_domain.com"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).not_to be_valid
@@ -78,7 +82,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "fails if the diaspora* ID contains a special-chars in the username" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user$^%@example.com"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user$^%@example.com"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).not_to be_valid
@@ -86,7 +90,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "fails if the diaspora* ID contains uppercase characters in the username" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "SOME_USER@example.com"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("SOME_USER@example.com"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).not_to be_valid
@@ -94,7 +98,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "fails if the diaspora* ID contains uppercase characters in the domain-name" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "some_user@EXAMPLE.com"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("some_user@EXAMPLE.com"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).not_to be_valid
@@ -102,7 +106,7 @@ describe Validation::Rule::DiasporaId do
     end
 
     it "fails if the diaspora* ID is longer than 255 characters" do
-      validator = Validation::Validator.new(OpenStruct.new(diaspora_id: "#{'a' * 244}@example.com"))
+      validator = Validation::Validator.new(DiasporaIdHolder.new("#{'a' * 244}@example.com"))
       validator.rule(:diaspora_id, :diaspora_id)
 
       expect(validator).not_to be_valid
@@ -111,7 +115,7 @@ describe Validation::Rule::DiasporaId do
 
     it "fails for nil and empty" do
       [nil, ""].each do |val|
-        validator = Validation::Validator.new(OpenStruct.new(diaspora_id: val))
+        validator = Validation::Validator.new(DiasporaIdHolder.new(val))
         validator.rule(:diaspora_id, :diaspora_id)
 
         expect(validator).not_to be_valid

spec/lib/diaspora_federation/validators/rules/guid_spec.rb

@@ -12,9 +12,13 @@ describe Validation::Rule::Guid do
     expect(described_class.new.error_key).to eq(:guid)
   end
 
-  context "validation" do
+  context "when validating" do
+    before do
+      stub_const("GuidHolder", Struct.new(:guid))
+    end
+
     it "validates a string at least 16 chars long, consisting of [0-9a-f] (diaspora)" do
-      validator = Validation::Validator.new(OpenStruct.new(guid: "abcdef0123456789"))
+      validator = Validation::Validator.new(GuidHolder.new("abcdef0123456789"))
       validator.rule(:guid, :guid)
 
       expect(validator).to be_valid
@@ -22,9 +26,7 @@ describe Validation::Rule::Guid do
     end
 
     it "validates a long string with random characters and [-_@.:] (redmatrix)" do
-      validator = Validation::Validator.new(
+      validator = Validation::Validator.new(GuidHolder.new("1234567890ABCDefgh_ijkl-mnopqrSTUVwxyz@example.com:3000"))
-        OpenStruct.new(guid: "1234567890ABCDefgh_ijkl-mnopqrSTUVwxyz@example.com:3000")
-      )
       validator.rule(:guid, :guid)
 
       expect(validator).to be_valid
@@ -32,7 +34,7 @@ describe Validation::Rule::Guid do
     end
 
     it "fails if the string is too short" do
-      validator = Validation::Validator.new(OpenStruct.new(guid: "012345"))
+      validator = Validation::Validator.new(GuidHolder.new("012345"))
       validator.rule(:guid, :guid)
 
       expect(validator).not_to be_valid
@@ -40,7 +42,7 @@ describe Validation::Rule::Guid do
     end
 
     it "fails if the string is too long" do
-      validator = Validation::Validator.new(OpenStruct.new(guid: "a" * 256))
+      validator = Validation::Validator.new(GuidHolder.new("a" * 256))
       validator.rule(:guid, :guid)
 
       expect(validator).not_to be_valid
@@ -48,7 +50,7 @@ describe Validation::Rule::Guid do
     end
 
     it "fails if the string contains special chars at the end" do
-      validator = Validation::Validator.new(OpenStruct.new(guid: "abcdef0123456789."))
+      validator = Validation::Validator.new(GuidHolder.new("abcdef0123456789."))
       validator.rule(:guid, :guid)
 
       expect(validator).not_to be_valid
@@ -56,7 +58,7 @@ describe Validation::Rule::Guid do
     end
 
     it "fails if the string contains invalid chars" do
-      validator = Validation::Validator.new(OpenStruct.new(guid: "ghijklmnopqrstuvwxyz++"))
+      validator = Validation::Validator.new(GuidHolder.new("ghijklmnopqrstuvwxyz++"))
       validator.rule(:guid, :guid)
 
       expect(validator).not_to be_valid
@@ -65,7 +67,7 @@ describe Validation::Rule::Guid do
 
     it "fails if the string is empty" do
       [nil, ""].each do |val|
-        validator = Validation::Validator.new(OpenStruct.new(guid: val))
+        validator = Validation::Validator.new(GuidHolder.new(val))
         validator.rule(:guid, :guid)
 
         expect(validator).not_to be_valid

spec/lib/diaspora_federation/validators/rules/not_nil_spec.rb

@@ -12,34 +12,38 @@ describe Validation::Rule::NotNil do
     expect(described_class.new.error_key).to eq(:not_nil)
   end
 
-  context "validation" do
+  context "when validating" do
+    before do
+      stub_const("ValueHolder", Struct.new(:value))
+    end
+
     it "validates a string" do
-      validator = Validation::Validator.new(OpenStruct.new(not_nil: "abcd"))
+      validator = Validation::Validator.new(ValueHolder.new("abcd"))
-      validator.rule(:not_nil, :not_nil)
+      validator.rule(:value, :not_nil)
 
       expect(validator).to be_valid
       expect(validator.errors).to be_empty
     end
 
     it "validates a object" do
-      validator = Validation::Validator.new(OpenStruct.new(not_nil: Object.new))
+      validator = Validation::Validator.new(ValueHolder.new(Object.new))
-      validator.rule(:not_nil, :not_nil)
+      validator.rule(:value, :not_nil)
 
       expect(validator).to be_valid
       expect(validator.errors).to be_empty
     end
 
     it "fails if it is nil" do
-      validator = Validation::Validator.new(OpenStruct.new(not_nil: nil))
+      validator = Validation::Validator.new(ValueHolder.new(nil))
-      validator.rule(:not_nil, :not_nil)
+      validator.rule(:value, :not_nil)
 
       expect(validator).not_to be_valid
-      expect(validator.errors).to include(:not_nil)
+      expect(validator.errors).to include(:value)
     end
 
     it "allows an empty string" do
-      validator = Validation::Validator.new(OpenStruct.new(not_nil: ""))
+      validator = Validation::Validator.new(ValueHolder.new(""))
-      validator.rule(:not_nil, :not_nil)
+      validator.rule(:value, :not_nil)
 
       expect(validator).to be_valid
       expect(validator.errors).to be_empty

spec/lib/diaspora_federation/validators/rules/public_key_spec.rb

@@ -12,7 +12,11 @@ describe Validation::Rule::PublicKey do
     expect(described_class.new.error_key).to eq(:public_key)
   end
 
-  context "validation" do
+  context "when validating" do
+    before do
+      stub_const("PublicKeyHolder", Struct.new(:key))
+    end
+
     ["PUBLIC KEY", "RSA PUBLIC KEY"].each do |key_type|
       context key_type do
         let(:prefix) { "-----BEGIN #{key_type}-----" }
@@ -21,7 +25,7 @@ describe Validation::Rule::PublicKey do
         let(:key) { "#{prefix}\nAAAAAA==\n#{suffix}\n" }
 
         it "validates an exported RSA key" do
-          validator = Validation::Validator.new(OpenStruct.new(key: key))
+          validator = Validation::Validator.new(PublicKeyHolder.new(key))
           validator.rule(:key, :public_key)
 
           expect(validator).to be_valid
@@ -29,7 +33,7 @@ describe Validation::Rule::PublicKey do
         end
 
         it "strips whitespace" do
-          validator = Validation::Validator.new(OpenStruct.new(key: "  \n   #{key}\n \n  "))
+          validator = Validation::Validator.new(PublicKeyHolder.new("  \n   #{key}\n \n  "))
           validator.rule(:key, :public_key)
 
           expect(validator).to be_valid
@@ -37,7 +41,7 @@ describe Validation::Rule::PublicKey do
         end
 
         it "fails if the prefix is missing" do
-          validator = Validation::Validator.new(OpenStruct.new(key: "\nAAAAAA==\n#{suffix}\n"))
+          validator = Validation::Validator.new(PublicKeyHolder.new("\nAAAAAA==\n#{suffix}\n"))
           validator.rule(:key, :public_key)
 
           expect(validator).not_to be_valid
@@ -45,7 +49,7 @@ describe Validation::Rule::PublicKey do
         end
 
         it "fails if the suffix is missing" do
-          validator = Validation::Validator.new(OpenStruct.new(key: "#{prefix}\nAAAAAA==\n\n"))
+          validator = Validation::Validator.new(PublicKeyHolder.new("#{prefix}\nAAAAAA==\n\n"))
           validator.rule(:key, :public_key)
 
           expect(validator).not_to be_valid
@@ -54,7 +58,7 @@ describe Validation::Rule::PublicKey do
 
         it "fails if the key is nil or empty" do
           [nil, ""].each do |val|
-            validator = Validation::Validator.new(OpenStruct.new(key: val))
+            validator = Validation::Validator.new(PublicKeyHolder.new(val))
             validator.rule(:key, :public_key)
 
             expect(validator).not_to be_valid

spec/lib/diaspora_federation/validators/rules/tag_count_spec.rb

@@ -21,11 +21,15 @@ describe Validation::Rule::TagCount do
     expect(described_class.new(maximum: 5).error_key).to eq(:tag_count)
   end
 
-  context "validation" do
+  context "when validating" do
     let(:tag_str) { "#i #love #tags" }
 
+    before do
+      stub_const("TagsHolder", Struct.new(:tags))
+    end
+
     it "validates less tags" do
-      validator = Validation::Validator.new(OpenStruct.new(tags: tag_str))
+      validator = Validation::Validator.new(TagsHolder.new(tag_str))
       validator.rule(:tags, tag_count: {maximum: 5})
 
       expect(validator).to be_valid
@@ -33,7 +37,7 @@ describe Validation::Rule::TagCount do
     end
 
     it "validates exactly as many tags" do
-      validator = Validation::Validator.new(OpenStruct.new(tags: tag_str))
+      validator = Validation::Validator.new(TagsHolder.new(tag_str))
       validator.rule(:tags, tag_count: {maximum: 3})
 
       expect(validator).to be_valid
@@ -41,7 +45,7 @@ describe Validation::Rule::TagCount do
     end
 
     it "fails for too many tags" do
-      validator = Validation::Validator.new(OpenStruct.new(tags: tag_str))
+      validator = Validation::Validator.new(TagsHolder.new(tag_str))
       validator.rule(:tags, tag_count: {maximum: 1})
 
       expect(validator).not_to be_valid
@@ -50,7 +54,7 @@ describe Validation::Rule::TagCount do
 
     it "allows nil and empty" do
       [nil, ""].each do |val|
-        validator = Validation::Validator.new(OpenStruct.new(tags: val))
+        validator = Validation::Validator.new(TagsHolder.new(val))
         validator.rule(:tags, tag_count: {maximum: 5})
 
         expect(validator).to be_valid