rotp 4.0.0 → 6.3.0

data/spec/lib/rotp/cli_spec.rb

@@ -4,22 +4,30 @@ require 'rotp/cli'
 RSpec.describe ROTP::CLI do
   let(:cli)    { described_class.new('executable', argv) }
   let(:output) { cli.output }
-  let(:now)    { Time.utc 2012,1,1 }
+  let(:now)    { Time.utc 2012, 1, 1 }
 
   before do
     Timecop.freeze now
   end
 
   context 'generating a TOTP' do
-    let(:argv) { %w(--secret JBSWY3DPEHPK3PXP) }
+    let(:argv) { %w[--secret JBSWY3DPEHPK3PXP] }
 
     it 'prints the corresponding token' do
       expect(output).to eq '068212'
     end
   end
 
+  context 'generating a TOTP with sha256 digest' do
+    let(:argv) { %w[--secret JBSWY3DPEHPK3PXP --digest sha256] }
+
+    it 'prints the corresponding token' do
+      expect(output).to eq '544902'
+    end
+  end
+
   context 'generating a TOTP with no secret' do
-    let(:argv) { %W(--time --secret) }
+    let(:argv) { %w[--time --secret] }
 
     it 'prints the corresponding token' do
       expect(output).to match 'You must also specify a --secret'
@@ -27,7 +35,7 @@ RSpec.describe ROTP::CLI do
   end
 
   context 'generating a TOTP with bad base32 secret' do
-    let(:argv) { %W(--time --secret #{'1' * 32}) }
+    let(:argv) { %W[--time --secret #{'1' * 32}] }
 
     it 'prints the corresponding token' do
       expect(output).to match 'Secret must be in RFC4648 Base32 format'
@@ -35,7 +43,7 @@ RSpec.describe ROTP::CLI do
   end
 
   context 'trying to generate an unsupport type' do
-    let(:argv) { %W(--notreal --secret #{'a' * 32}) }
+    let(:argv) { %W[--notreal --secret #{'a' * 32}] }
 
     it 'prints the corresponding token' do
       expect(output).to match 'invalid option: --notreal'
@@ -43,11 +51,18 @@ RSpec.describe ROTP::CLI do
   end
 
   context 'generating a HOTP' do
-    let(:argv) { %W(--hmac --secret #{'a' * 32} --counter 1234) }
+    let(:argv) { %W[--hmac --secret #{'a' * 32} --counter 1234] }
 
     it 'prints the corresponding token' do
       expect(output).to eq '161024'
     end
   end
 
+  context 'generating a HOTP' do
+    let(:argv) { %W[--hmac --secret #{'a' * 32} --counter 1234 --digest sha256] }
+
+    it 'prints the corresponding token' do
+      expect(output).to eq '325941'
+    end
+  end
 end

data/spec/lib/rotp/hotp_spec.rb

@@ -14,6 +14,12 @@ RSpec.describe ROTP::HOTP do
       end
     end
 
+    context 'invalid counter' do
+      it 'raises an error' do
+        expect { hotp.at(-123_456) }.to raise_error(ArgumentError)
+      end
+    end
+
     context 'RFC compatibility' do
       let(:hotp) { ROTP::HOTP.new('GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ') }
 
@@ -31,7 +37,6 @@ RSpec.describe ROTP::HOTP do
         expect(hotp.at(8)).to eq '399871'
         expect(hotp.at(9)).to eq '520489'
       end
-
     end
   end
 
@@ -39,7 +44,7 @@ RSpec.describe ROTP::HOTP do
     let(:verification) { hotp.verify token, counter }
 
     context 'numeric token' do
-      let(:token) { 161024 }
+      let(:token) { 161_024 }
 
       it 'raises an error' do
         expect { verification }.to raise_error(ArgumentError)
@@ -62,7 +67,7 @@ RSpec.describe ROTP::HOTP do
       end
     end
     describe 'with retries' do
-      let(:verification) { hotp.verify token, counter, retries:retries }
+      let(:verification) { hotp.verify token, counter, retries: retries }
 
       context 'counter outside than retries' do
         let(:counter) { 1223 }
@@ -103,30 +108,46 @@ RSpec.describe ROTP::HOTP do
   end
 
   describe '#provisioning_uri' do
-    let(:uri)    { hotp.provisioning_uri('mark@percival') }
-    let(:params) { CGI::parse URI::parse(uri).query }
+    let(:hotp) { ROTP::HOTP.new('a' * 32, name: "m@mdp.im") }
+    let(:params) { CGI.parse URI.parse(uri).query }
+
+    it 'created from the otp instance data' do
+      expect(hotp.provisioning_uri())
+        .to eq 'otpauth://hotp/m%40mdp.im?secret=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&counter=0'
+    end
 
-    it 'has the correct format' do
-      expect(uri).to match %r{\Aotpauth:\/\/hotp.+}
+    it 'allow passing a name to override the OTP name' do
+      expect(hotp.provisioning_uri('mark@percival'))
+        .to eq 'otpauth://hotp/mark%40percival?secret=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&counter=0'
     end
 
-    it 'includes the secret as parameter' do
-      expect(params['secret'].first).to eq 'a' * 32
+    it 'also accepts a custom counter value' do
+      expect(hotp.provisioning_uri('mark@percival', 17))
+        .to eq 'otpauth://hotp/mark%40percival?secret=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&counter=17'
     end
 
-    context 'with default digits' do
-      it 'does not include digits parameter with default digits' do
-        expect(params['digits'].first).to be_nil
+    context 'with non-standard provisioning_params' do
+      let(:hotp) { ROTP::HOTP.new('a' * 32, digits: 8, provisioning_params: {image: 'https://example.com/icon.png'}) }
+      let(:uri)    { hotp.provisioning_uri("mark@percival") }
+
+      it 'includes the issuer as parameter' do
+        expect(params['image'].first).to eq 'https://example.com/icon.png'
       end
     end
 
-    context 'with non-default digits' do
-      let(:hotp) { ROTP::HOTP.new('a' * 32, digits: 8) }
+    context "with an issuer" do
+      let(:hotp) { ROTP::HOTP.new('a' * 32, name: "m@mdp.im", issuer: "Example.com") }
+
+      it 'created from the otp instance data' do
+        expect(hotp.provisioning_uri())
+          .to eq 'otpauth://hotp/Example.com:m%40mdp.im?secret=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&issuer=Example.com&counter=0'
+      end
 
-      it 'includes digits parameter' do
-        expect(params['digits'].first).to eq '8'
+      it 'allow passing a name to override the OTP name' do
+        expect(hotp.provisioning_uri('mark@percival'))
+          .to eq 'otpauth://hotp/Example.com:mark%40percival?secret=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&issuer=Example.com&counter=0'
       end
     end
-  end
 
+  end
 end

data/spec/lib/rotp/otp/uri_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+RSpec.describe ROTP::OTP::URI do
+  it 'meets basic functionality' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP')
+    uri = described_class.new(otp, account_name: 'alice@google.com')
+    expect(uri.to_s).to eq 'otpauth://totp/alice%40google.com?secret=JBSWY3DPEHPK3PXP'
+  end
+
+  it 'includes issuer' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', issuer: 'Example')
+    uri = described_class.new(otp, account_name: 'alice@google.com')
+    expect(uri.to_s).to eq 'otpauth://totp/Example:alice%40google.com?secret=JBSWY3DPEHPK3PXP&issuer=Example'
+  end
+
+  it 'encodes the account name' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', issuer: 'Provider1')
+    uri = described_class.new(otp, account_name: 'Alice Smith')
+    expect(uri.to_s).to eq 'otpauth://totp/Provider1:Alice%20Smith?secret=JBSWY3DPEHPK3PXP&issuer=Provider1'
+  end
+
+  it 'encodes the issuer' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', issuer: 'Big Corporation')
+    uri = described_class.new(otp, account_name: ' alice@bigco.com')
+    expect(uri.to_s).to eq 'otpauth://totp/Big%20Corporation:%20alice%40bigco.com?secret=JBSWY3DPEHPK3PXP&issuer=Big%20Corporation'
+  end
+
+  it 'includes non-default SHA256 algorithm' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', digest: 'sha256')
+    uri = described_class.new(otp, account_name: 'alice@google.com')
+    expect(uri.to_s).to eq 'otpauth://totp/alice%40google.com?secret=JBSWY3DPEHPK3PXP&algorithm=SHA256'
+  end
+
+  it 'includes non-default SHA512 algorithm' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', digest: 'sha512')
+    uri = described_class.new(otp, account_name: 'alice@google.com')
+    expect(uri.to_s).to eq 'otpauth://totp/alice%40google.com?secret=JBSWY3DPEHPK3PXP&algorithm=SHA512'
+  end
+
+  it 'includes non-default 8 digits' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', digits: 8)
+    uri = described_class.new(otp, account_name: 'alice@google.com')
+    expect(uri.to_s).to eq 'otpauth://totp/alice%40google.com?secret=JBSWY3DPEHPK3PXP&digits=8'
+  end
+
+  it 'includes non-default period for TOTP' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', interval: 35)
+    uri = described_class.new(otp, account_name: 'alice@google.com')
+    expect(uri.to_s).to eq 'otpauth://totp/alice%40google.com?secret=JBSWY3DPEHPK3PXP&period=35'
+  end
+
+  it 'includes non-default counter for HOTP' do
+    otp = ROTP::HOTP.new('JBSWY3DPEHPK3PXP')
+    uri = described_class.new(otp, account_name: 'alice@google.com', counter: 17)
+    expect(uri.to_s).to eq 'otpauth://hotp/alice%40google.com?secret=JBSWY3DPEHPK3PXP&counter=17'
+  end
+
+  it 'can include all parameters' do
+    otp = ROTP::TOTP.new(
+      'HXDMVJECJJWSRB3HWIZR4IFUGFTMXBOZ',
+      digest: 'sha512',
+      digits: 8,
+      interval: 60,
+      issuer: 'ACME Co',
+    )
+    uri = described_class.new(otp, account_name: 'john.doe@email.com')
+    expect(uri.to_s).to eq'otpauth://totp/ACME%20Co:john.doe%40email.com?secret=HXDMVJECJJWSRB3HWIZR4IFUGFTMXBOZ&issuer=ACME%20Co&algorithm=SHA512&digits=8&period=60'
+  end
+
+  it 'strips leading and trailing whitespace from the issuer' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', issuer: '  Big Corporation  ')
+    uri = described_class.new(otp, account_name: ' alice@bigco.com')
+    expect(uri.to_s).to eq 'otpauth://totp/Big%20Corporation:%20alice%40bigco.com?secret=JBSWY3DPEHPK3PXP&issuer=Big%20Corporation'
+  end
+
+  it 'strips trailing whitespace from the account name' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP')
+    uri = described_class.new(otp, account_name: '  alice@google.com  ')
+    expect(uri.to_s).to eq 'otpauth://totp/%20%20alice%40google.com?secret=JBSWY3DPEHPK3PXP'
+  end
+
+  it 'replaces colons in the issuer with underscores' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP', issuer: 'Big:Corporation')
+    uri = described_class.new(otp, account_name: 'alice@bigco.com')
+    expect(uri.to_s).to eq 'otpauth://totp/Big_Corporation:alice%40bigco.com?secret=JBSWY3DPEHPK3PXP&issuer=Big_Corporation'
+  end
+
+  it 'replaces colons in the account name with underscores' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP')
+    uri = described_class.new(otp, account_name: 'Alice:Smith')
+    expect(uri.to_s).to eq 'otpauth://totp/Alice_Smith?secret=JBSWY3DPEHPK3PXP'
+  end
+
+  it 'handles email account names with sub-addressing' do
+    otp = ROTP::TOTP.new('JBSWY3DPEHPK3PXP')
+    uri = described_class.new(otp, account_name: 'alice+1234@google.com')
+    expect(uri.to_s).to eq 'otpauth://totp/alice%2B1234%40google.com?secret=JBSWY3DPEHPK3PXP'
+  end
+end

data/spec/lib/rotp/totp_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
-TEST_TIME = Time.utc 2016,9,23,9 # 2016-09-23 09:00:00 UTC
-TEST_TOKEN = "082630"
+TEST_TIME = Time.utc 2016, 9, 23, 9 # 2016-09-23 09:00:00 UTC
+TEST_TOKEN = '082630'.freeze
+TEST_SECRET = 'JBSWY3DPEHPK3PXP'
 
 RSpec.describe ROTP::TOTP do
   let(:now)   { TEST_TIME }
   let(:token) { TEST_TOKEN }
-  let(:totp)  { ROTP::TOTP.new 'JBSWY3DPEHPK3PXP' }
+  let(:totp)  { ROTP::TOTP.new TEST_SECRET }
 
   describe '#at' do
     let(:token) { totp.at now }
@@ -19,11 +20,10 @@ RSpec.describe ROTP::TOTP do
       let(:totp) { ROTP::TOTP.new('GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ') }
 
       it 'matches the RFC documentation examples' do
-        expect(totp.at 1111111111).to eq '050471'
-        expect(totp.at 1234567890).to eq '005924'
-        expect(totp.at 2000000000).to eq '279037'
+        expect(totp.at(1_111_111_111)).to eq '050471'
+        expect(totp.at(1_234_567_890)).to eq '005924'
+        expect(totp.at(2_000_000_000)).to eq '279037'
       end
-
     end
   end
 
@@ -31,7 +31,7 @@ RSpec.describe ROTP::TOTP do
     let(:verification) { totp.verify token, at: now }
 
     context 'numeric token' do
-      let(:token) { 82630 }
+      let(:token) { 82_630 }
 
       it 'raises an error with an integer' do
         expect { verification }.to raise_error(ArgumentError)
@@ -53,7 +53,7 @@ RSpec.describe ROTP::TOTP do
     end
 
     context 'RFC compatibility' do
-      let(:totp)  { ROTP::TOTP.new 'wrn3pqx5uqxqvnqr' }
+      let(:totp) { ROTP::TOTP.new 'wrn3pqx5uqxqvnqr' }
 
       before do
         Timecop.freeze now
@@ -61,7 +61,7 @@ RSpec.describe ROTP::TOTP do
 
       context 'correct time based OTP' do
         let(:token) { '102705' }
-        let(:now)   { Time.at 1297553958 }
+        let(:now)   { Time.at 1_297_553_958 }
 
         it 'verifies' do
           expect(totp.verify('102705')).to be_truthy
@@ -75,17 +75,17 @@ RSpec.describe ROTP::TOTP do
       end
     end
     context 'invalidating reused tokens' do
-      let(:verification) {
+      let(:verification) do
         totp.verify token,
-        after: after,
-        at: now
-      }
+                    after: after,
+                    at: now
+      end
       let(:after) { nil }
 
       context 'passing in the `after` timestamp' do
-        let(:after) {
+        let(:after) do
           totp.verify TEST_TOKEN, after: nil, at: now
-        }
+        end
 
         it 'returns a timecode' do
           expect(after).to be_kind_of(Integer)
@@ -106,23 +106,23 @@ RSpec.describe ROTP::TOTP do
     totp.send('get_timecodes', at, b, a)
   end
 
-  describe "drifting timecodes" do
+  describe 'drifting timecodes' do
     it 'should get timecodes behind' do
-      expect(get_timecodes(TEST_TIME+15, 15, 0)).to eq([49154040])
-      expect(get_timecodes(TEST_TIME, 15, 0)).to eq([49154039, 49154040])
-      expect(get_timecodes(TEST_TIME, 40, 0)).to eq([49154038, 49154039, 49154040])
-      expect(get_timecodes(TEST_TIME, 90, 0)).to eq([49154037, 49154038, 49154039, 49154040])
+      expect(get_timecodes(TEST_TIME + 15, 15, 0)).to eq([49_154_040])
+      expect(get_timecodes(TEST_TIME, 15, 0)).to eq([49_154_039, 49_154_040])
+      expect(get_timecodes(TEST_TIME, 40, 0)).to eq([49_154_038, 49_154_039, 49_154_040])
+      expect(get_timecodes(TEST_TIME, 90, 0)).to eq([49_154_037, 49_154_038, 49_154_039, 49_154_040])
     end
     it 'should get timecodes ahead' do
-      expect(get_timecodes(TEST_TIME, 0, 15)).to eq([49154040])
-      expect(get_timecodes(TEST_TIME+15, 0, 15)).to eq([49154040, 49154041])
-      expect(get_timecodes(TEST_TIME, 0, 30)).to eq([49154040, 49154041])
-      expect(get_timecodes(TEST_TIME, 0, 70)).to eq([49154040, 49154041, 49154042])
-      expect(get_timecodes(TEST_TIME, 0, 90)).to eq([49154040, 49154041, 49154042, 49154043])
+      expect(get_timecodes(TEST_TIME, 0, 15)).to eq([49_154_040])
+      expect(get_timecodes(TEST_TIME + 15, 0, 15)).to eq([49_154_040, 49_154_041])
+      expect(get_timecodes(TEST_TIME, 0, 30)).to eq([49_154_040, 49_154_041])
+      expect(get_timecodes(TEST_TIME, 0, 70)).to eq([49_154_040, 49_154_041, 49_154_042])
+      expect(get_timecodes(TEST_TIME, 0, 90)).to eq([49_154_040, 49_154_041, 49_154_042, 49_154_043])
     end
     it 'should get timecodes behind and ahead' do
-      expect(get_timecodes(TEST_TIME, 30, 30)).to eq([49154039, 49154040, 49154041])
-      expect(get_timecodes(TEST_TIME, 60, 60)).to eq([49154038, 49154039, 49154040, 49154041, 49154042])
+      expect(get_timecodes(TEST_TIME, 30, 30)).to eq([49_154_039, 49_154_040, 49_154_041])
+      expect(get_timecodes(TEST_TIME, 60, 60)).to eq([49_154_038, 49_154_039, 49_154_040, 49_154_041, 49_154_042])
     end
   end
 
@@ -131,7 +131,6 @@ RSpec.describe ROTP::TOTP do
     let(:drift_ahead) { 0 }
     let(:drift_behind) { 0 }
 
-
     context 'with an old OTP' do
       let(:token) { totp.at TEST_TIME - 30 } # Previous token at 2016-09-23 08:59:30 UTC
       let(:drift_behind) { 15 }
@@ -151,7 +150,6 @@ RSpec.describe ROTP::TOTP do
           expect(verification).to be_nil
         end
       end
-
     end
 
     context 'with a future OTP' do
@@ -166,14 +164,13 @@ RSpec.describe ROTP::TOTP do
       # Tested at 2016-09-23 09:00:20 UTC, and with drift ahead to 2016-09-23 09:00:35 UTC
       # This would therefore include 2 intervals
       context 'inside of drift range' do
-        let(:now)   { TEST_TIME + 20 }
+        let(:now) { TEST_TIME + 20 }
 
         it 'is true' do
           expect(verification).to be_truthy
         end
       end
     end
-
   end
 
   describe '#verify with drift and prevent token reuse' do
@@ -183,7 +180,6 @@ RSpec.describe ROTP::TOTP do
     let(:after) { nil }
 
     context 'with the `after` timestamp set' do
-
       context 'older token' do
         let(:token) { totp.at TEST_TIME - 30 }
         let(:drift_behind) { 15 }
@@ -194,14 +190,13 @@ RSpec.describe ROTP::TOTP do
         end
 
         context 'after it has been used' do
-          let(:after) {
+          let(:after) do
             totp.verify token, after: nil, at: now, drift_behind: drift_behind
-          }
+          end
           it 'is false' do
             expect(verification).to be_falsey
           end
         end
-
       end
 
       context 'newer token' do
@@ -215,92 +210,61 @@ RSpec.describe ROTP::TOTP do
         end
 
         context 'after it has been used' do
-          let(:after) {
+          let(:after) do
             totp.verify token, after: nil, at: now, drift_ahead: drift_ahead
-          }
+          end
           it 'is false' do
             expect(verification).to be_falsey
           end
         end
-
       end
     end
   end
 
-  describe '#provisioning_uri' do
-    let(:uri)    { totp.provisioning_uri('mark@percival') }
-    let(:params) { CGI::parse URI::parse(uri).query }
-
-    context 'without issuer' do
-      it 'has the correct format' do
-        expect(uri).to match %r{\Aotpauth:\/\/totp.+}
-      end
 
-      it 'includes the secret as parameter' do
-        expect(params['secret'].first).to eq 'JBSWY3DPEHPK3PXP'
-      end
-    end
+  describe '#provisioning_uri' do
+    let(:params) { CGI.parse URI.parse(uri).query }
 
-    context 'with default digits' do
-      it 'does does not include digits parameter' do
-        expect(params['digits'].first).to be_nil
+    context "with a provided name on the TOTP instance" do
+      let(:totp) { ROTP::TOTP.new(TEST_SECRET, name: "m@mdp.im") }
+      it 'creates a provisioning uri from the OTP instance' do
+        expect(totp.provisioning_uri())
+          .to eq 'otpauth://totp/m%40mdp.im?secret=JBSWY3DPEHPK3PXP'
       end
-    end
 
-    context 'with non-default digits' do
-      let(:totp)  { ROTP::TOTP.new 'JBSWY3DPEHPK3PXP', digits: 8 }
-
-      it 'does does not include digits parameter' do
-        expect(params['digits'].first).to eq '8'
+      it 'allow passing a name to override the OTP name' do
+        expect(totp.provisioning_uri('mark@percival'))
+          .to eq 'otpauth://totp/mark%40percival?secret=JBSWY3DPEHPK3PXP'
       end
     end
 
-    context 'with issuer' do
-      let(:totp)  { ROTP::TOTP.new 'JBSWY3DPEHPK3PXP', issuer: 'FooCo' }
-
-      it 'has the correct format' do
-        expect(uri).to match %r{\Aotpauth:\/\/totp/FooCo:.+}
-      end
-
-      it 'includes the secret as parameter' do
-        expect(params['secret'].first).to eq 'JBSWY3DPEHPK3PXP'
-      end
+    context 'with non-standard provisioning_params' do
+      let(:totp)    {
+        ROTP::TOTP.new(TEST_SECRET,
+          provisioning_params: { image: 'https://example.com/icon.png' }
+        )
+      }
+      let(:uri)    { totp.provisioning_uri("mark@percival") }
 
       it 'includes the issuer as parameter' do
-        expect(params['issuer'].first).to eq 'FooCo'
+        expect(params['image'].first).to eq 'https://example.com/icon.png'
       end
-    end
-
-    context 'with custom interval' do
-      let(:totp)  { ROTP::TOTP.new 'JBSWY3DPEHPK3PXP', interval: 60 }
 
-      it 'has the correct format' do
-        expect(uri).to match %r{\Aotpauth:\/\/totp.+}
-      end
-
-      it 'includes the secret as parameter' do
-        expect(params['secret'].first).to eq 'JBSWY3DPEHPK3PXP'
-      end
-
-      it 'includes the interval as period parameter' do
-        expect(params['period'].first).to eq '60'
-      end
     end
 
-    context 'with custom digest' do
-      let(:totp)  { ROTP::TOTP.new 'JBSWY3DPEHPK3PXP', digest: 'sha256' }
+    context "with an issuer" do
+      let(:totp) { ROTP::TOTP.new(TEST_SECRET, name: "m@mdp.im", issuer: "Example.com") }
 
-      it 'has the correct format' do
-        expect(uri).to match %r{\Aotpauth:\/\/totp.+}
+      it 'creates a provisioning uri from the OTP instance' do
+        expect(totp.provisioning_uri())
+          .to eq 'otpauth://totp/Example.com:m%40mdp.im?secret=JBSWY3DPEHPK3PXP&issuer=Example.com'
       end
 
-      it 'includes the secret as parameter' do
-        expect(params['secret'].first).to eq 'JBSWY3DPEHPK3PXP'
+      it 'allow passing a name to override the OTP name' do
+        expect(totp.provisioning_uri('mark@percival'))
+          .to eq 'otpauth://totp/Example.com:mark%40percival?secret=JBSWY3DPEHPK3PXP&issuer=Example.com'
       end
 
-      it 'includes the digest as algorithm parameter' do
-        expect(params['algorithm'].first).to eq 'SHA256'
-      end
     end
 
   end
@@ -312,7 +276,7 @@ RSpec.describe ROTP::TOTP do
 
     context 'Google Authenticator' do
       let(:totp) { ROTP::TOTP.new 'wrn3pqx5uqxqvnqr' }
-      let(:now)  { Time.at 1297553958 }
+      let(:now)  { Time.at 1_297_553_958 }
 
       it 'matches the known output' do
         expect(totp.now).to eq '102705'
@@ -321,12 +285,11 @@ RSpec.describe ROTP::TOTP do
 
     context 'Dropbox 26 char secret output' do
       let(:totp) { ROTP::TOTP.new 'tjtpqea6a42l56g5eym73go2oa' }
-      let(:now)  { Time.at 1378762454 }
+      let(:now)  { Time.at 1_378_762_454 }
 
       it 'matches the known output' do
         expect(totp.now).to eq '747864'
       end
     end
   end
-
 end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require 'simplecov'
 SimpleCov.start do
-  add_filter "/spec/"
+  add_filter '/spec/'
 end
 
 require 'rotp'
@@ -17,5 +17,4 @@ RSpec.configure do |config|
   end
 end
 
-
 require_relative '../lib/rotp'