spec/fernet_spec.rb in fernet-1.4 vs spec/fernet_spec.rb in fernet-1.5

@@ -14,65 +14,82 @@
   it 'can verify tokens it generates' do
     token = Fernet.generate(secret) do |generator|
       generator.data = token_data
     end
 
-    Fernet.verify(secret, token) do |verifier|
-      verifier.data['email'] == '[e-mail]'
-    end.should be_true
+    expect(
+      Fernet.verify(secret, token) do |verifier|
+        verifier.data['email'] == '[e-mail]'
+      end
+    ).to be_true
   end
 
   it 'fails with a bad secret' do
     token = Fernet.generate(secret) do |generator|
       generator.data = token_data
     end
 
-    Fernet.verify(bad_secret, token) do |verifier|
-      verifier.data['email'] == '[e-mail]'
-    end.should be_false
+    expect(
+      Fernet.verify(bad_secret, token) do |verifier|
+        verifier.data['email'] == '[e-mail]'
+      end
+    ).to be_false
   end
 
   it 'fails with a bad custom verification' do
     token = Fernet.generate(secret) do |generator|
-      generator.data = token_data
+      generator.data = { :email => '[e-mail]' }
     end
 
-    Fernet.verify(bad_secret, token) do |verifier|
-      verifier.data['email'] == '[e-mail]'
-    end.should be_false
+    expect(
+      Fernet.verify(secret, token) do |verifier|
+        verifier.data['email'] == '[e-mail]'
+      end
+    ).to be_false
   end
 
   it 'fails if the token is too old' do
     token = Fernet.generate(secret) do |generator|
       generator.data = token_data
     end
 
-    Fernet.verify(bad_secret, token) do |verifier|
-      verifier.ttl = 0
-    end.should be_false
+    expect(
+      Fernet.verify(secret, token) do |verifier|
+        verifier.ttl = 1
+
+        def verifier.now
+          now = DateTime.now
+          DateTime.new(now.year, now.month, now.day, now.hour,
+                       now.min, now.sec + 2, now.offset)
+        end
+        true
+      end
+    ).to be_false
   end
 
   it 'verifies without a custom verification' do
     token = Fernet.generate(secret) do |generator|
       generator.data = token_data
     end
 
-    Fernet.verify(secret, token).should be_true
+    expect(Fernet.verify(secret, token)).to be_true
   end
 
   it 'can ignore TTL enforcement' do
     token = Fernet.generate(secret) do |generator|
       generator.data = token_data
     end
 
-    Fernet.verify(secret, token) do |verifier|
-      def verifier.now
-        Time.now + 99999999999
+    expect(
+      Fernet.verify(secret, token) do |verifier|
+        def verifier.now
+          Time.now + 99999999999
+        end
+        verifier.enforce_ttl = false
+        true
       end
-      verifier.enforce_ttl = false
-      true
-    end.should be_true
+    ).to be_true
   end
 
   it 'can ignore TTL enforcement via global config' do
     Fernet::Configuration.run do |config|
       config.enforce_ttl = false
@@ -80,69 +97,68 @@
 
     token = Fernet.generate(secret) do |generator|
       generator.data = token_data
     end
 
-    Fernet.verify(secret, token) do |verifier|
-      def verifier.now
-        Time.now + 99999999999
+    expect(
+      Fernet.verify(secret, token) do |verifier|
+        def verifier.now
+          Time.now + 99999999999
+        end
+        true
       end
-      true
-    end.should be_true
+    ).to be_true
   end
 
   it 'generates without custom data' do
     token = Fernet.generate(secret)
 
-    Fernet.verify(secret, token).should be_true
+    expect(Fernet.verify(secret, token)).to be_true
   end
 
   it 'can encrypt the payload' do
     token = Fernet.generate(secret, true) do |generator|
       generator.data['password'] = 'password1'
     end
 
-    payload = Base64.decode64(token)
-    payload.should_not match /password1/
+    expect(Base64.decode64(token)).not_to match /password1/
 
     Fernet.verify(secret, token) do |verifier|
-      verifier.data['password'].should == 'password1'
+      expect(verifier.data['password']).to eq('password1')
     end
   end
 
   it 'does not encrypt when asked nicely' do
     token = Fernet.generate(secret, false) do |generator|
       generator.data['password'] = 'password1'
     end
 
-    payload = Base64.decode64(token)
-    payload.should match /password1/
+    expect(Base64.decode64(token)).to match /password1/
 
     Fernet.verify(secret, token, false) do |verifier|
-      verifier.data['password'].should == 'password1'
+      expect(verifier.data['password']).to eq('password1')
     end
   end
 
   it 'can disable encryption via global configuration' do
     Fernet::Configuration.run { |c| c.encrypt = false }
     token = Fernet.generate(secret) do |generator|
       generator.data['password'] = 'password1'
     end
 
-    payload = Base64.decode64(token)
-    payload.should match /password1/
+    expect(Base64.decode64(token)).to match /password1/
 
     Fernet.verify(secret, token) do |verifier|
-      verifier.data['password'].should == 'password1'
+      expect(verifier.data['password']).to eq('password1')
     end
   end
 
   it 'returns the unencrypted message upon verify' do
     token = Fernet.generate(secret) do |generator|
       generator.data['password'] = 'password1'
     end
 
     verifier = Fernet.verifier(secret, token)
-    verifier.should be_valid
-    verifier.data['password'].should == 'password1'
+    expect(verifier.valid?).to be_true
+    expect(verifier.data['password']).to eq('password1')
   end
 end