symmetric-encryption 3.7.2 → 3.8.0

data/test/reader_test.rb

@@ -4,17 +4,17 @@ require 'stringio'
 # Unit Test for SymmetricEncrypted::ReaderStream
 #
 class ReaderTest < Minitest::Test
-  context SymmetricEncryption::Reader do
-    setup do
-      @data = [
+  describe SymmetricEncryption::Reader do
+    before do
+      @data                          = [
         "Hello World\n",
         "Keep this secret\n",
         "And keep going even further and further..."
       ]
-      @data_str = @data.inject('') {|sum,str| sum << str}
-      @data_len = @data_str.length
+      @data_str                      = @data.inject('') { |sum, str| sum << str }
+      @data_len                      = @data_str.length
       # Use Cipher 0 since it does not always include a header
-      @cipher = SymmetricEncryption.cipher(0)
+      @cipher                        = SymmetricEncryption.cipher(0)
       @data_encrypted_without_header = @cipher.binary_encrypt(@data_str)
 
       @data_encrypted_with_header = SymmetricEncryption::Cipher.build_header(
@@ -33,20 +33,20 @@ class ReaderTest < Minitest::Test
     end
 
     [true, false].each do |header|
-      context header do
-        setup do
+      describe header do
+        before do
           @data_encrypted = header ? @data_encrypted_with_header : @data_encrypted_without_header
         end
 
-        should "#read()" do
-          stream = StringIO.new(@data_encrypted)
+        it "#read()" do
+          stream    = StringIO.new(@data_encrypted)
           # Version 0 supplied if the file/stream does not have a header
-          decrypted = SymmetricEncryption::Reader.open(stream, version: 0) {|file| file.read}
+          decrypted = SymmetricEncryption::Reader.open(stream, version: 0) { |file| file.read }
           assert_equal @data_str, decrypted
         end
 
-        should "#read(size) followed by #read()" do
-          stream = StringIO.new(@data_encrypted)
+        it "#read(size) followed by #read()" do
+          stream    = StringIO.new(@data_encrypted)
           # Version 0 supplied if the file/stream does not have a header
           decrypted = SymmetricEncryption::Reader.open(stream, version: 0) do |file|
             file.read(10)
@@ -55,9 +55,9 @@ class ReaderTest < Minitest::Test
           assert_equal @data_str[10..-1], decrypted
         end
 
-        should "#each_line" do
-          stream = StringIO.new(@data_encrypted)
-          i = 0
+        it "#each_line" do
+          stream    = StringIO.new(@data_encrypted)
+          i         = 0
           # Version 0 supplied if the file/stream does not have a header
           decrypted = SymmetricEncryption::Reader.open(stream, version: 0) do |file|
             file.each_line do |line|
@@ -67,13 +67,13 @@ class ReaderTest < Minitest::Test
           end
         end
 
-        should "#read(size)" do
-          stream = StringIO.new(@data_encrypted)
-          i = 0
+        it "#read(size)" do
+          stream    = StringIO.new(@data_encrypted)
+          i         = 0
           # Version 0 supplied if the file/stream does not have a header
           decrypted = SymmetricEncryption::Reader.open(stream, version: 0) do |file|
             index = 0
-            [0,10,5,5000].each do |size|
+            [0, 10, 5, 5000].each do |size|
               buf = file.read(size)
               if size == 0
                 assert_equal '', buf
@@ -106,30 +106,30 @@ class ReaderTest < Minitest::Test
 
       [:data, :empty, :blank].each do |usecase|
 
-        context "read from #{usecase} file with options: #{options.inspect}" do
-          setup do
+        describe "read from #{usecase} file with options: #{options.inspect}" do
+          before do
             case usecase
             when :data
               # Create encrypted file
-              @eof = false
+              @eof      = false
               @filename = '_test'
-              @header = (options[:header] != false)
+              @header   = (options[:header] != false)
               SymmetricEncryption::Writer.open(@filename, options) do |file|
-                @data.inject(0) {|sum,str| sum + file.write(str)}
+                @data.inject(0) { |sum, str| sum + file.write(str) }
               end
             when :empty
               @data_str = ''
-              @eof = true
+              @eof      = true
               @filename = '_test_empty'
-              @header = (options[:header] != false)
+              @header   = (options[:header] != false)
               SymmetricEncryption::Writer.open(@filename, options) do |file|
                 # Leave data portion empty
               end
             when :blank
               @data_str = ''
-              @eof = true
+              @eof      = true
               @filename = File.join(File.dirname(__FILE__), 'config/empty.csv')
-              @header = false
+              @header   = false
               assert_equal 0, File.size(@filename)
             else
               raise "Unhandled usecase: #{usecase}"
@@ -137,35 +137,35 @@ class ReaderTest < Minitest::Test
             @data_size = @data_str.length
           end
 
-          teardown do
+          after do
             File.delete(@filename) if File.exist?(@filename) && !@filename.end_with?('empty.csv')
           end
 
-          should ".empty?" do
+          it ".empty?" do
             assert_equal (@data_size==0), SymmetricEncryption::Reader.empty?(@filename)
             assert_raises Errno::ENOENT do
               SymmetricEncryption::Reader.empty?('missing_file')
             end
           end
 
-          should ".header_present?" do
+          it ".header_present?" do
             assert_equal @header, SymmetricEncryption::Reader.header_present?(@filename)
             assert_raises Errno::ENOENT do
               SymmetricEncryption::Reader.header_present?('missing_file')
             end
           end
 
-          should ".open return Zlib::GzipReader when compressed" do
+          it ".open return Zlib::GzipReader when compressed" do
             file = SymmetricEncryption::Reader.open(@filename)
             #assert_equal (@header && (options[:compress]||false)), file.is_a?(Zlib::GzipReader)
             file.close
           end
 
-          should "#read()" do
-            data = nil
-            eof = nil
+          it "#read()" do
+            data   = nil
+            eof    = nil
             result = SymmetricEncryption::Reader.open(@filename) do |file|
-              eof = file.eof?
+              eof  = file.eof?
               data = file.read
             end
             assert_equal @eof, eof
@@ -173,9 +173,9 @@ class ReaderTest < Minitest::Test
             assert_equal @data_str, result
           end
 
-          should "#read(size)" do
+          it "#read(size)" do
             file = SymmetricEncryption::Reader.open(@filename)
-            eof = file.eof?
+            eof  = file.eof?
             data = file.read(4096)
             file.close
 
@@ -183,7 +183,7 @@ class ReaderTest < Minitest::Test
             assert_equal (@data_size > 0 ? @data_str : nil), data
           end
 
-          should "#each_line" do
+          it "#each_line" do
             decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
               i = 0
               file.each_line do |line|
@@ -193,7 +193,7 @@ class ReaderTest < Minitest::Test
             end
           end
 
-          should "#rewind" do
+          it "#rewind" do
             decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
               file.read
               file.rewind
@@ -202,10 +202,10 @@ class ReaderTest < Minitest::Test
             assert_equal @data_str, decrypted
           end
 
-          should "#gets(nil,size)" do
+          it "#gets(nil,size)" do
             file = SymmetricEncryption::Reader.open(@filename)
-            eof = file.eof?
-            data = file.gets(nil,4096)
+            eof  = file.eof?
+            data = file.gets(nil, 4096)
             file.close
 
             assert_equal @eof, eof
@@ -222,7 +222,7 @@ class ReaderTest < Minitest::Test
             end
           end
 
-          should "#gets(delim)" do
+          it "#gets(delim)" do
             decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
               i = 0
               while line = file.gets("\n")
@@ -233,10 +233,10 @@ class ReaderTest < Minitest::Test
             end
           end
 
-          should "#gets(delim,size)" do
+          it "#gets(delim,size)" do
             decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
               i = 0
-              while line = file.gets("\n",128)
+              while line = file.gets("\n", 128)
                 i += 1
               end
               assert_equal (@data_size > 0 ? 3 : 0), i
@@ -247,25 +247,25 @@ class ReaderTest < Minitest::Test
       end
     end
 
-    context "reading from files with previous keys" do
-      setup do
+    describe "reading from files with previous keys" do
+      before do
         @filename = '_test'
         # Create encrypted file with old encryption key
         SymmetricEncryption::Writer.open(@filename, version: 0) do |file|
-          @data.inject(0) {|sum,str| sum + file.write(str)}
+          @data.inject(0) { |sum, str| sum + file.write(str) }
         end
       end
 
-      teardown do
+      after do
         File.delete(@filename) if File.exist?(@filename)
       end
 
-      should "decrypt from file in a single read" do
-        decrypted = SymmetricEncryption::Reader.open(@filename) {|file| file.read}
+      it "decrypt from file in a single read" do
+        decrypted = SymmetricEncryption::Reader.open(@filename) { |file| file.read }
         assert_equal @data_str, decrypted
       end
 
-      should "decrypt from file a line at a time" do
+      it "decrypt from file a line at a time" do
         decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
           i = 0
           file.each_line do |line|
@@ -275,7 +275,7 @@ class ReaderTest < Minitest::Test
         end
       end
 
-      should "support rewind" do
+      it "support rewind" do
         decrypted = SymmetricEncryption::Reader.open(@filename) do |file|
           file.read
           file.rewind
@@ -285,16 +285,16 @@ class ReaderTest < Minitest::Test
       end
     end
 
-    context "reading from files with previous keys without a header" do
-      setup do
+    describe "reading from files with previous keys without a header" do
+      before do
         @filename = '_test'
         # Create encrypted file with old encryption key
         SymmetricEncryption::Writer.open(@filename, version: 0, header: false, random_key: false) do |file|
-          @data.inject(0) {|sum,str| sum + file.write(str)}
+          @data.inject(0) { |sum, str| sum + file.write(str) }
         end
       end
 
-      teardown do
+      after do
         begin
           File.delete(@filename) if File.exist?(@filename)
         rescue Errno::EACCES
@@ -302,15 +302,15 @@ class ReaderTest < Minitest::Test
         end
       end
 
-      should "decrypt from file in a single read" do
-        decrypted = SymmetricEncryption::Reader.open(@filename, version: 0) {|file| file.read}
+      it "decrypt from file in a single read" do
+        decrypted = SymmetricEncryption::Reader.open(@filename, version: 0) { |file| file.read }
         assert_equal @data_str, decrypted
       end
 
-      should "decrypt from file in a single read with different version" do
+      it "decrypt from file in a single read with different version" do
         # Should fail since file was encrypted using version 0 key
         assert_raises OpenSSL::Cipher::CipherError do
-          SymmetricEncryption::Reader.open(@filename, version: 2) {|file| file.read}
+          SymmetricEncryption::Reader.open(@filename, version: 2) { |file| file.read }
         end
       end
     end

data/test/symmetric_encryption_test.rb

@@ -3,15 +3,16 @@ require_relative 'test_helper'
 # Unit Test for SymmetricEncryption
 #
 class SymmetricEncryptionTest < Minitest::Test
-  context 'SymmetricEncryption' do
+  describe 'SymmetricEncryption' do
 
-    context 'configuration' do
-      setup do
-        @ciphers = SymmetricEncryption.send(:read_config, File.join(File.dirname(__FILE__), 'config', 'symmetric-encryption.yml'), 'test')
+    describe 'configuration' do
+      before do
+        config                             = SymmetricEncryption::Config.read_config(File.join(File.dirname(__FILE__), 'config', 'symmetric-encryption.yml'), 'test')
+        @ciphers                           = SymmetricEncryption::Config.extract_ciphers(config)
         @cipher_v2, @cipher_v1, @cipher_v0 = @ciphers
       end
 
-      should "match config file for first cipher" do
+      it 'matches config file for first cipher' do
         cipher = SymmetricEncryption.cipher
         assert @cipher_v2.send(:key)
         assert @cipher_v2.send(:iv)
@@ -21,7 +22,7 @@ class SymmetricEncryptionTest < Minitest::Test
         assert_equal false, SymmetricEncryption.secondary_ciphers.include?(cipher)
       end
 
-      should "match config file for v1 cipher" do
+      it 'match config file for v1 cipher' do
         cipher = SymmetricEncryption.cipher(2)
         assert @cipher_v2.cipher_name
         assert @cipher_v2.version
@@ -30,7 +31,7 @@ class SymmetricEncryptionTest < Minitest::Test
         assert_equal false, SymmetricEncryption.secondary_ciphers.include?(cipher)
       end
 
-      should "match config file for v0 cipher" do
+      it 'match config file for v0 cipher' do
         cipher = SymmetricEncryption.cipher(0)
         assert @cipher_v0.cipher_name
         assert @cipher_v0.version
@@ -41,43 +42,43 @@ class SymmetricEncryptionTest < Minitest::Test
     end
 
     SymmetricEncryption::Cipher::ENCODINGS.each do |encoding|
-      context "encoding: #{encoding}" do
-        setup do
-          @social_security_number = "987654321"
-          @social_security_number_encrypted =
+      describe "encoding: #{encoding}" do
+        before do
+          @social_security_number                            = '987654321'
+          @social_security_number_encrypted                  =
             case encoding
-          when :base64
-            "QEVuQwIAS+8X1NRrqdfEIQyFHVPuVA==\n"
-          when :base64strict
-            "QEVuQwIAS+8X1NRrqdfEIQyFHVPuVA=="
-          when :base16
-            "40456e4302004bef17d4d46ba9d7c4210c851d53ee54"
-          when :none
-            "@EnC\x02\x00K\xEF\x17\xD4\xD4k\xA9\xD7\xC4!\f\x85\x1DS\xEET".force_encoding(Encoding.find("binary"))
-          else
-            raise "Add test for encoding: #{encoding}"
-          end
+            when :base64
+              "QEVuQwIAS+8X1NRrqdfEIQyFHVPuVA==\n"
+            when :base64strict
+              'QEVuQwIAS+8X1NRrqdfEIQyFHVPuVA=='
+            when :base16
+              '40456e4302004bef17d4d46ba9d7c4210c851d53ee54'
+            when :none
+              "@EnC\x02\x00K\xEF\x17\xD4\xD4k\xA9\xD7\xC4!\f\x85\x1DS\xEET".force_encoding(Encoding.find("binary"))
+            else
+              raise "Add test for encoding: #{encoding}"
+            end
           @social_security_number_encrypted_with_secondary_1 = "D1UCu38pqJ3jc0GvwJHiow==\n"
-          @non_utf8 = "\xc2".force_encoding('binary')
-          @encoding = SymmetricEncryption.cipher.encoding
-          SymmetricEncryption.cipher.encoding = encoding
+          @non_utf8                                          = "\xc2".force_encoding('binary')
+          @encoding                                          = SymmetricEncryption.cipher.encoding
+          SymmetricEncryption.cipher.encoding                = encoding
         end
 
-        teardown do
+        after do
           SymmetricEncryption.cipher.encoding = @encoding
         end
 
-        should "encrypt simple string" do
+        it "encrypt simple string" do
           assert_equal @social_security_number_encrypted, SymmetricEncryption.encrypt(@social_security_number)
         end
 
-        should "decrypt string" do
+        it "decrypt string" do
           assert decrypted = SymmetricEncryption.decrypt(@social_security_number_encrypted)
           assert_equal @social_security_number, decrypted
           assert_equal Encoding.find('utf-8'), decrypted.encoding, decrypted
         end
 
-        should 'return BINARY encoding for non-UTF-8 encrypted data' do
+        it 'return BINARY encoding for non-UTF-8 encrypted data' do
           assert_equal Encoding.find('binary'), @non_utf8.encoding
           assert_equal true, @non_utf8.valid_encoding?
           assert encrypted = SymmetricEncryption.encrypt(@non_utf8)
@@ -87,34 +88,34 @@ class SymmetricEncryptionTest < Minitest::Test
           assert_equal @non_utf8, decrypted
         end
 
-        should "return nil when encrypting nil" do
+        it "return nil when encrypting nil" do
           assert_equal nil, SymmetricEncryption.encrypt(nil)
         end
 
-        should "return '' when encrypting ''" do
+        it "return '' when encrypting ''" do
           assert_equal '', SymmetricEncryption.encrypt('')
         end
 
-        should "return nil when decrypting nil" do
+        it "return nil when decrypting nil" do
           assert_equal nil, SymmetricEncryption.decrypt(nil)
         end
 
-        should "return '' when decrypting ''" do
+        it "return '' when decrypting ''" do
           assert_equal '', SymmetricEncryption.decrypt('')
         end
 
-        should "determine if string is encrypted" do
+        it "determine if string is encrypted" do
           assert_equal true, SymmetricEncryption.encrypted?(@social_security_number_encrypted)
           assert_equal false, SymmetricEncryption.encrypted?(@social_security_number)
         end
       end
     end
 
-    context "using select_cipher" do
-      setup do
+    describe "using select_cipher" do
+      before do
         @social_security_number = "987654321"
         # Encrypt data without a header and encode with base64 which has a trailing '\n'
-        @encrypted_0_ssn = SymmetricEncryption.cipher(0).encode(SymmetricEncryption.cipher(0).binary_encrypt(@social_security_number,false,false,false))
+        @encrypted_0_ssn        = SymmetricEncryption.cipher(0).encode(SymmetricEncryption.cipher(0).binary_encrypt(@social_security_number, false, false, false))
 
         SymmetricEncryption.select_cipher do |encoded_str, decoded_str|
           # Use cipher version 0 if the encoded string ends with "\n" otherwise
@@ -123,43 +124,43 @@ class SymmetricEncryptionTest < Minitest::Test
         end
       end
 
-      teardown do
+      after do
         # Clear out select_cipher
         SymmetricEncryption.select_cipher
       end
 
-      should "decrypt string without a header using an old cipher" do
+      it "decrypt string without a header using an old cipher" do
         assert_equal @social_security_number, SymmetricEncryption.decrypt(@encrypted_0_ssn)
       end
     end
 
-    context "without select_cipher" do
-      setup do
+    describe "without select_cipher" do
+      before do
         @social_security_number = "987654321"
         # Encrypt data without a header and encode with base64 which has a trailing '\n'
-        assert @encrypted_0_ssn = SymmetricEncryption.cipher(0).encode(SymmetricEncryption.cipher(0).binary_encrypt(@social_security_number,false,false,false))
+        assert @encrypted_0_ssn = SymmetricEncryption.cipher(0).encode(SymmetricEncryption.cipher(0).binary_encrypt(@social_security_number, false, false, false))
       end
 
-      should "decrypt string without a header using an old cipher" do
+      it "decrypt string without a header using an old cipher" do
         assert_raises OpenSSL::Cipher::CipherError do
           SymmetricEncryption.decrypt(@encrypted_0_ssn)
         end
       end
     end
 
-    context "random iv" do
-      setup do
+    describe "random iv" do
+      before do
         @social_security_number = "987654321"
       end
 
-      should "encrypt and then decrypt using random iv" do
+      it "encrypt and then decrypt using random iv" do
         # Encrypt with random iv
         assert encrypted = SymmetricEncryption.encrypt(@social_security_number, random_iv=true)
         assert_equal true, SymmetricEncryption.encrypted?(encrypted)
         assert_equal @social_security_number, SymmetricEncryption.decrypt(encrypted)
       end
 
-      should "encrypt and then decrypt using random iv with compression" do
+      it "encrypt and then decrypt using random iv with compression" do
         # Encrypt with random iv and compress
         assert encrypted = SymmetricEncryption.encrypt(@social_security_number, random_iv=true, compress=true)
         assert_equal true, SymmetricEncryption.encrypted?(encrypted)
@@ -167,122 +168,122 @@ class SymmetricEncryptionTest < Minitest::Test
       end
     end
 
-    context "data types" do
-      context "string" do
-        setup do
+    describe "data types" do
+      describe "string" do
+        before do
           @social_security_number = "987654321"
         end
 
-        should "encrypt and decrypt value to and from a string" do
+        it "encrypt and decrypt value to and from a string" do
           assert encrypted = SymmetricEncryption.encrypt(@social_security_number, random_iv=false, compress=false, type=:string)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
           assert_equal @social_security_number, SymmetricEncryption.decrypt(encrypted, version=nil, type=:string)
         end
       end
 
-      context "integer" do
-        setup do
+      describe "integer" do
+        before do
           @age = 21
         end
 
-        should "encrypt and decrypt value to and from an integer" do
+        it "encrypt and decrypt value to and from an integer" do
           assert encrypted = SymmetricEncryption.encrypt(@age, random_iv=false, compress=false, type=:integer)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
           assert_equal @age, SymmetricEncryption.decrypt(encrypted, version=nil, type=:integer)
         end
       end
 
-      context "float" do
-        setup do
+      describe "float" do
+        before do
           @miles = 2.5
         end
 
-        should "encrypt and decrypt value to and from a float" do
+        it "encrypt and decrypt value to and from a float" do
           assert encrypted = SymmetricEncryption.encrypt(@miles, random_iv=false, compress=false, type=:float)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
           assert_equal @miles, SymmetricEncryption.decrypt(encrypted, version=nil, type=:float)
         end
       end
 
-      context "decimal" do
-        setup do
+      describe "decimal" do
+        before do
           @account_balance = BigDecimal.new("12.58")
         end
 
-        should "encrypt and decrypt value to and from a BigDecimal" do
+        it "encrypt and decrypt value to and from a BigDecimal" do
           assert encrypted = SymmetricEncryption.encrypt(@account_balance, random_iv=false, compress=false, type=:decimal)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
           assert_equal @account_balance, SymmetricEncryption.decrypt(encrypted, version=nil, type=:decimal)
         end
       end
 
-      context "datetime" do
-        setup do
+      describe "datetime" do
+        before do
           @checked_in_at = DateTime.new(2001, 11, 26, 20, 55, 54, "-5")
         end
 
-        should "encrypt and decrypt value to and from a DateTime" do
+        it "encrypt and decrypt value to and from a DateTime" do
           assert encrypted = SymmetricEncryption.encrypt(@checked_in_at, random_iv=false, compress=false, type=:datetime)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
           assert_equal @checked_in_at, SymmetricEncryption.decrypt(encrypted, version=nil, type=:datetime)
         end
       end
 
-      context "time" do
-        setup do
+      describe "time" do
+        before do
           @closing_time = Time.new(2013, 01, 01, 22, 30, 00, "-04:00")
         end
 
-        should "encrypt and decrypt value to and from a Time" do
+        it "encrypt and decrypt value to and from a Time" do
           assert encrypted = SymmetricEncryption.encrypt(@closing_time, random_iv=false, compress=false, type=:time)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
           assert_equal @closing_time, SymmetricEncryption.decrypt(encrypted, version=nil, type=:time)
         end
       end
 
-      context "date" do
-        setup do
+      describe "date" do
+        before do
           @birthdate = Date.new(1927, 04, 01)
         end
 
-        should "encrypt and decrypt value to and from a Date" do
+        it "encrypt and decrypt value to and from a Date" do
           assert encrypted = SymmetricEncryption.encrypt(@birthdate, random_iv=false, compress=false, type=:date)
           assert_equal true, SymmetricEncryption.encrypted?(encrypted)
           assert_equal @birthdate, SymmetricEncryption.decrypt(encrypted, version=nil, type=:date)
         end
       end
 
-      context "boolean" do
-        context "when true" do
-          setup do
+      describe "boolean" do
+        describe "when true" do
+          before do
             @is_working = true
           end
 
-          should "encrypt and decrypt a true value to and from a boolean" do
+          it "encrypt and decrypt a true value to and from a boolean" do
             assert encrypted = SymmetricEncryption.encrypt(@is_working, random_iv=false, compress=false, type=:boolean)
             assert_equal true, SymmetricEncryption.encrypted?(encrypted)
             assert_equal @is_working, SymmetricEncryption.decrypt(encrypted, version=nil, type=:boolean)
           end
         end
 
-        context "when false" do
-          setup do
+        describe "when false" do
+          before do
             @is_broken = false
           end
 
-          should "encrypt and decrypt a false value to and from a boolean" do
+          it "encrypt and decrypt a false value to and from a boolean" do
             assert encrypted = SymmetricEncryption.encrypt(@is_broken, random_iv=false, compress=false, type=:boolean)
             assert_equal true, SymmetricEncryption.encrypted?(encrypted)
             assert_equal @is_broken, SymmetricEncryption.decrypt(encrypted, version=nil, type=:boolean)
           end
         end
 
-        context "when yaml" do
-          setup do
-            @test = { :a => :b }
+        describe "when yaml" do
+          before do
+            @test = {:a => :b}
           end
 
-          should "encrypt and decrypt a false value to and from a boolean" do
+          it "encrypt and decrypt a false value to and from a boolean" do
             assert encrypted = SymmetricEncryption.encrypt(@test, random_iv=false, compress=false, type=:yaml)
             assert_equal true, SymmetricEncryption.encrypted?(encrypted)
             assert_equal @test, SymmetricEncryption.decrypt(encrypted, version=nil, type=:yaml)