write tests to have 100% coverage again

lib/diaspora_federation/properties_dsl.rb

@@ -82,8 +82,6 @@ module DiasporaFederation
         type.first.entity_name.to_sym
       elsif type.ancestors.include?(Entity)
         type.entity_name.to_sym
-      else
-        raise ArgumentError, "unknown type #{type} supplied"
       end
     end
 

lib/diaspora_federation/validators/rules/diaspora_id_count.rb

@@ -9,7 +9,7 @@ module Validation
       # @option params [Fixnum] :maximum maximum allowed id count
       def initialize(params)
         unless params.include?(:maximum) && params[:maximum].is_a?(Fixnum)
-          raise "A number has to be specified for :maximum"
+          raise ArgumentError, "A number has to be specified for :maximum"
         end
 
         @params = params

spec/lib/diaspora_federation/signing_spec.rb

@@ -49,11 +49,19 @@ RSA
 
     describe ".verify_signature" do
       it "verifies correct signature" do
-        expect(Signing.verify_signature(hash, signature, pkey)).to be_truthy
+        expect(Signing.verify_signature(hash, signature, pkey.public_key)).to be_truthy
       end
 
       it "doesn't verify wrong signature" do
-        expect(Signing.verify_signature(hash, "false signature==", pkey)).to be_falsy
+        expect(Signing.verify_signature(hash, "false signature==", pkey.public_key)).to be_falsy
+      end
+
+      it "doesn't verify when signature is missing" do
+        expect(Signing.verify_signature(hash, nil, pkey.public_key)).to be_falsy
+      end
+
+      it "doesn't verify when public key is missing" do
+        expect(Signing.verify_signature(hash, signature, nil)).to be_falsy
       end
     end
   end

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

@@ -8,36 +8,51 @@ describe Validation::Rule::DiasporaIdCount do
     }.to raise_error ArgumentError
   end
 
-  it "validates less ids" do
+  it "requires a integer as parameter" do
-    validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+    validator = Validation::Validator.new({})
-    validator.rule(:ids, diaspora_id_count: {maximum: 5})
+    [nil, "", 5.5].each do |val|
-
+      expect {
-    expect(validator).to be_valid
+        validator.rule(:ids, diaspora_id_count: {maximum: val})
-    expect(validator.errors).to be_empty
+      }.to raise_error ArgumentError, "A number has to be specified for :maximum"
+    end
   end
 
-  it "fails for less but non ids" do
+  it "has an error key" do
-    bad_str = "user@example.com;i am a weird diaspora id @@@ ### 12345;shouldnt be reached by a rule"
+    expect(described_class.new(maximum: 5).error_key).to eq(:diaspora_id_count)
-    validator = Validation::Validator.new(OpenStruct.new(ids: bad_str))
-    validator.rule(:ids, diaspora_id_count: {maximum: 5})
-
-    expect(validator).not_to be_valid
-    expect(validator.errors).to include(:ids)
   end
 
-  it "validates exactly as many ids" do
+  context "validation" do
-    validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+    it "validates less ids" do
-    validator.rule(:ids, diaspora_id_count: {maximum: 3})
+      validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      validator.rule(:ids, diaspora_id_count: {maximum: 5})
 
-    expect(validator).to be_valid
+      expect(validator).to be_valid
-    expect(validator.errors).to be_empty
+      expect(validator.errors).to be_empty
-  end
+    end
 
-  it "fails for too many ids" do
+    it "fails for less but non ids" do
-    validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      bad_str = "user@example.com;i am a weird diaspora id @@@ ### 12345;shouldnt be reached by a rule"
-    validator.rule(:ids, diaspora_id_count: {maximum: 1})
+      validator = Validation::Validator.new(OpenStruct.new(ids: bad_str))
+      validator.rule(:ids, diaspora_id_count: {maximum: 5})
 
-    expect(validator).not_to be_valid
+      expect(validator).not_to be_valid
-    expect(validator.errors).to include(:ids)
+      expect(validator.errors).to include(:ids)
+    end
+
+    it "validates exactly as many ids" do
+      validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      validator.rule(:ids, diaspora_id_count: {maximum: 3})
+
+      expect(validator).to be_valid
+      expect(validator.errors).to be_empty
+    end
+
+    it "fails for too many ids" do
+      validator = Validation::Validator.new(OpenStruct.new(ids: id_str))
+      validator.rule(:ids, diaspora_id_count: {maximum: 1})
+
+      expect(validator).not_to be_valid
+      expect(validator.errors).to include(:ids)
+    end
   end
 end