trivial_sso 4.0.0.3 → 4.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 757d1e6efcab4ef502c3b7081079211f9b59efb2
-  data.tar.gz: 132360a31cfd6b5c8e5859c50acb907f433b30a4
+  metadata.gz: 936981875ed9f86e1f13252e3b2e98f86280b32e
+  data.tar.gz: 5c59ef3e7aec280fdba6918b50095ff354600ef0
 SHA512:
-  metadata.gz: 513db9226ecb8da76264c56cc7c202355aff18553627c2f3b8c47d30758e0839d4509ba4553ec32953f14189a3b871f7329a13cd57552e7c8f36c9e0bd80f30e
-  data.tar.gz: 0e1edc9ec2f99d0cd34424292107a32eaf54374c26060e7bab067bbf699b97c4a6adbbfc8ca25894556cd4dbb8d25d424ca534487f15877ebd29c72aee275834
+  metadata.gz: 39c154dbe5a77da77ee19f011022384858d912831261c6f632f287e37598a1ec79c21a6da827ccd6d789e55f32143f9b22b24255948cad946c4be5f5766b9d00
+  data.tar.gz: 68e0396f2c4aab07a10084c3c482a1464274c19a851eb26930e66ad68658783fe76ec9a2706b41e025896707dff1942a941fa194f2c6c3526767c30c8770d087

data/CHANGELOG.md

@@ -1,6 +1,9 @@
 ## TrivialSso Change Log ##
 ### Changelog ###
 
+### 4.0.2
+- expose the default expire on the Login class
+
 ### 4.0.0.3
 - ease the required ruby back to 1.9.3
 

data/README.md

@@ -1,3 +1,5 @@
+[![Code Climate](https://codeclimate.com/github/nacengineer/trivialsso.png)](https://codeclimate.com/github/nacengineer/trivialsso)
+
 ## TrivialSso
 
 A very simple gem to help with creating and reading cookies across multiple sites in a Ruby on Rails application.
@@ -26,84 +28,98 @@ After you've installed the gem, you need to generate a configuration file.
 
 This will create an initializer file with a shared secret. You need to modify this to a big long string of characters. Keep this safe from others as they could forge cookies for your sites if they get ahold of this string. All sites that use the single sign on must have this same shared secret for the cookies to properly interoperate.
 
-## Creating a cookie
+## Creating an encrpyted string
+### Uses [ActiveSupport::MessageEncryptor](http://api.rubyonrails.org/classes/ActiveSupport/MessageEncryptor.html)
+
+A encrypted and signed string is created using of data supplied to it via a [ruby Hash](http://www.ruby-doc.org/core-2.0/Hash.html).
+
+This only requirement is that the Hash must contain a **username** key.
+
+When you create the encrypted string an expire time is added to the payload. You have the option of either providing one, or a default of 9 hours from the current time will be used.
 
-A cookie is created using a hash of data supplied to it. This must contain a **username** key.
+Note: Setting the [ActionDispatch#expires](http://api.rubyonrails.org/classes/ActionDispatch/Cookies.html) on the cookie is just a convenience to make sure it gets cleared by the browser.
 
-When you create the cookie data an expire time is built into the payload. Setting the **:expires** on the cookie is just a convenience to make sure it gets cleared by the browser. The actual expiration date that matters is what is encoded in the cookie.
+The actual expiration date that is enforced by the application  is what is encoded in the cookie.4
 
-    ```ruby
-    # Create a hash of data we want to store in the cookie.
-    userdata = {
-      "username" => current_user.login,
-      "display"  => current_user.display_name,
-      "groups"   => current_user.memberof
-    }
+Essentiall it is all boiled down to the follwoing...
 
-    #Generate the cookie data
-    cookie = TrivialSso::Login.cookie(userdata)
+### create a userdata hash
 
-    # Set the cookie
-    cookies[:sso_login] = {
-      :value    => cookie,
-      :expires  => TrivialSso::Login.expire_date,
-      :domain   => 'mydomain.com',
-      :httponly => true,
-    }
-    ```
+```ruby
+# Create a hash of data we want to store in the cookie.
+userdata = {
+  "username" => current_user.login,
+  "display"  => current_user.display_name,
+  "groups"   => current_user.memberof
+}
+
+#### Generate the cookie data with Api.encode
+cookie = TrivialSso::Api.encode(userdata)
+
+#### Set the cookie
+cookies[:sso_login] = {
+  :value    => cookie,
+  :expires  => TrivialSso::Login.default_expire,
+  :domain   => 'mydomain.com',
+  :httponly => true
+}
+```
 
 The above code creates a hash of data we will be putting in the cookie, generates the cookie, and then sets the cookie in the browser.
 
-## Decoding a cookie
+### Decoding a cookie
 
-Retrieve the contents of the cookie by calling decode_cookie
+Retrieve the contents of the cookie by calling Api.decode
 
-    @userdata = TrivialSso::Login.decode_cookie(cookies[:sso_login])
+```ruby
+@userdata = TrivialSso::Api.decode(cookies[:sso_login])
+```
 
-This will throw an exception if the cookie has been tampered with, or if the expiration date has passed.
+This will return the originally encoded data as a __Hash__ with string keys.
+
+NOTE: This will throw an exception if the cookie has been tampered with, or if the expiration date has passed.
 
 ## Sample code for application_controller
 
 Here are some methods you can add into your application controller to authenticate against the cookie.
 
-    ```ruby
-    # If there is a problem with the cookie, redirect back to our central login server.
-    rescue_from TrivialSso::CookieError do |exception|
-      redirect_to 'https://login.mydomain.com/'
-    end
-
-    # authorize our users based on the cookie.
-    before_filter :auth_user!
-
-    # authenticate a user and set @current_user
-    def auth_user!
-      cu = current_user
-
-      # Check for authorization based on "groups" data that was put in the cookie
-      # by the central login application.
-      # you could also skip this check and just return true if the cookie is valid.
-      if cu['groups'].include? "ALLOWED_GROUP"    #all lower case
-        @current_user = cu
-        true
-      else
-        render :file => "#{Rails.root}/public/403", :formats => [:html], :status => 403, :layout => false
-      end
-
-      false
-    end
-
-    # our current_user decodes the cookie.
-    def current_user
-      TrivialSso::Login.decode_cookie(cookies[:sso_login])
-    end
-
-    # Define the name we want to record in paper_trail (if using)
-    def user_for_paper_trail
-      if @current_user.blank?
-        "anonymous"
-      else
-        @current_user['username']
-      end
-    end
-    ```
-
+```ruby
+# If there is a problem with the cookie, redirect back to our central login server.
+rescue_from TrivialSso::CookieError do |exception|
+  redirect_to 'https://login.mydomain.com/'
+end
+
+# authorize our users based on the cookie.
+before_filter :auth_user!
+
+# authenticate a user and set @current_user
+def auth_user!
+  cu = current_user
+
+  # Check for authorization based on "groups" data that was put in the cookie
+  # by the central login application.
+  # you could also skip this check and just return true if the cookie is valid.
+  if cu['groups'].include? "ALLOWED_GROUP"    #all lower case
+    @current_user = cu
+    true
+  else
+    render :file => "#{Rails.root}/public/403", :formats => [:html], :status => 403, :layout => false
+  end
+
+  false
+end
+
+# our current_user decodes the cookie.
+def current_user
+  TrivialSso::Api.decode(cookies[:sso_login])
+end
+
+# Define the name we want to record in paper_trail (if using)
+def user_for_paper_trail
+  if @current_user.blank?
+    "anonymous"
+  else
+    @current_user['username']
+  end
+end
+```

data/lib/trivial_sso/api.rb

@@ -0,0 +1,19 @@
+module TrivialSso
+  class Api
+
+    class <<self
+
+      def encode(data, expire_time = nil, secret = nil)
+        TrivialSso::Login.new(
+          {data: data, expire_time: expire_time, secret: secret}
+        ).wrap
+      end
+
+      def decode(data, secret = nil)
+        TrivialSso::Login.new({data: data, secret: secret}).unwrap
+      end
+
+    end
+
+  end
+end

data/lib/trivial_sso/error.rb

@@ -8,13 +8,46 @@ module TrivialSso
       end
     end
 
-    # Cookie can not be verified, data has been altered
-    class BadCookie < CookieError
+    class MissingConfig < RuntimeError
       def to_s
-        "Login cookie can not be verified!"
+        "There is something wrong with the config of this application"
       end
     end
 
+    # Cookie can not be verified, data has been altered
+    module BadData
+
+      class Signature < CookieError
+        def to_s
+          "The data signature supplied was not valid."
+        end
+      end
+
+      # Cookie can not be verified, data has been altered
+      class Message < CookieError
+        def to_s
+          "The data supplied was not valid. i.e. bad cookie data given"
+        end
+      end
+
+      class Given < CookieError
+        def to_s
+          <<-HERE
+          The data supplied is useless to me. i.e. Can't Wrap or Unwrap.
+          Try passing me some good data.
+          HERE
+        end
+      end
+
+      # Cookie is missing
+      class Missing < CookieError
+        def to_s
+          "No data was given."
+        end
+      end
+
+    end
+
     # cookie is no longer valid
     class LoginExpired < CookieError
       def to_s
@@ -22,24 +55,27 @@ module TrivialSso
       end
     end
 
-    # Cookie is missing
-    class MissingCookie < CookieError
+    # Cookie is lacking a username.
+    class NoUsernameData < CookieError
       def to_s
-        "Login cookie is missing!"
+        "Need username to create cookie"
       end
     end
 
-    # Cookie is lacking a username.
-    class NoUsernameCookie < CookieError
+    # Missing configuration value.
+    class MissingRailsConfig < CookieError
       def to_s
-        "Need username to create cookie"
+        <<-HERE
+        Missing secret configuration for cookie, need to define
+        config.sso_secret
+        HERE
       end
     end
 
     # Missing configuration value.
-    class MissingConfig < CookieError
+    class MissingSecret < CookieError
       def to_s
-        "Missing secret configuration for cookie, need to define config.sso_secret"
+        "Missing secret, need to define sso_secret"
       end
     end
 
@@ -50,5 +86,23 @@ module TrivialSso
       end
     end
 
+
+    class BadExpireTime < CookieError
+      def to_s
+        <<-HERE
+        The expire_time is useless to me. i.e. its not an Time object
+        transormed to integer time. Please retry with good data.
+        HERE
+      end
+    end
+
+    module Mode
+      class Wrong < CookieError
+        def to_s
+          "Can't use same object to decode and encode"
+        end
+      end
+    end
+
   end
 end

data/lib/trivial_sso/login.rb

@@ -1,76 +1,89 @@
 module TrivialSso
   class Login
 
-    # signing and un-signing may have to be refactored to use OpenSSL:HMAC...
-    # as this will not work well across platforms. (ideally this should work for PHP as well)
-
-    # Decodes and verifies an encrypted cookie
-    # throw a proper exception if a bad or invalid cookie.
-    # otherwise, return the username and userdata stored in the cookie
-    def self.decode_cookie(cookie = nil)
-      begin
-        raise TrivialSso::Error::MissingCookie if cookie.nil? || cookie.empty?
-        userdata, timestamp = encrypted_message.decrypt_and_verify(cookie)
-        raise TrivialSso::Error::LoginExpired if check_timestamp(timestamp)
-        userdata
-      rescue NoMethodError
-        raise TrivialSso::Error::MissingConfig
-      rescue ActiveSupport::MessageVerifier::InvalidSignature ||
-             ActiveSupport::MessageEncryptor::InvalidMessage
-        raise TrivialSso::Error::BadCookie
-      end
+    attr_accessor :data, :secret, :expire_time, :struct
+    attr_reader   :wrap, :unwrap, :mode, :secret, :default_expire
+
+    def initialize(opts = {})
+      opts[:expire_time] = default_expire unless opts[:expire_time]
+      opts[:secret]      = default_secret unless opts[:secret]
+      opts.each {|k,v| send("#{k}=".to_sym, v) if available_opts.include?(k.to_sym)}
+    end
+
+    def expire_time=(value)
+      @expire_time = time_or_default(value) if time_value_good?(value)
     end
 
-    # create an encrypted and signed cookie containing userdata and an expiry date.
-    # userdata should be an array, and at minimum include a 'username' key.
-    # using json serializer to hopefully allow future cross version compatibliity
-    # (Marshall, the default serializer, is not compatble between versions)
-    def self.cookie(userdata, expire_date = default_expire_date)
-      begin
-        raise TrivialSso::Error::MissingConfig    if sso_secret
-        raise TrivialSso::Error::NoUsernameCookie if check_username(userdata)
-        enc.encrypt_and_sign([userdata, expire_date])
-      rescue NoMethodError
-        raise TrivialSso::Error::MissingConfig
+    def data=(value)
+      if value.is_a?(String)
+        @mode, @data = :unwrap, value
+      elsif value.is_a?(Hash)
+        @mode, @data = :wrap, OpenStruct.new(value)
+      else
+        raise Error::BadData::Given
       end
     end
 
-   private
+    def wrap
+      check_mode_set
+      raise Error::Mode::Wrong unless mode == __method__
+      TrivialSso::Wrap.new(data, sso_secret, expire_time).wrap
+    end
+
+    def unwrap
+      check_mode_set
+      raise Error::Mode::Wrong unless mode == __method__
+      response = TrivialSso::UnWrap.new(data, sso_secret).unwrap
+      struct ? OpenStruct.new(response) : response
+    end
 
-    def self.check_username(userdata)
-        userdata.nil?                 ||
-        userdata.empty?               ||
-      ! userdata.has_key?('username') ||
-        userdata['username'].empty?
+    def sso_secret
+      TrivialSso::Secret.new(secret).sso_secret
     end
 
-    def self.enc
-      ActiveSupport::MessageEncryptor.new(sso_secret , serializer: JSON)
+    def default_expire
+      (Time.now + 32400).to_i # 9 hours from now
     end
 
-    def self.default_expire_date
-      (9.hours.from_now).to_i
+   private
+
+    def default_secret
+      get_defined_sso_secret || SecureRandom.hex(64)
+    end
+
+    def get_defined_sso_secret
+      if rails_sso_secret_exists?
+        Rails.configuration.sso_secret
+      elsif defined? Rails
+        raise Error::MissingRailsConfig
+      else
+        false
+      end
     end
 
-    def self.check_timestamp(timestamp)
-      (timestamp - DateTime.now.to_i) <= 0
+    def rails_sso_secret_exists?
+      defined?(Rails) && Rails.configuration.sso_secret
     end
 
-    def self.encrypted_message
-      raise TrivialSso::Error::MissingRails unless defined? Rails
-      ActiveSupport::MessageEncryptor.new(sso_secret, serializer: JSON)
+    def check_mode_set
+      raise Error::BadData::Given if mode.nil? || mode.empty?
     end
 
-    def self.sso_secret
-      check_for_rails
-      if Rails.configuration.sso_secret.nil? || Rails.configuration.sso_secret.empty?
-        raise TrivialSso::Error::MissingConfig
+    def time_value_good?(value)
+      if (value.is_a?(Integer) || value.is_a?(String)) && value.to_s.length == 10
+        true
+      else
+        raise Error::BadExpireTime
       end
-      Rails.configuration.sso_secret
     end
 
-    def self.check_for_rails
-      raise TrivialSso::Error::MissingRails unless defined?(Rails)
+    def time_or_default(value)
+      value.to_i.nonzero? ? value.to_i : default_expire
+    end
+
+
+    def available_opts
+      [:data, :secret, :expire_time]
     end
 
   end

data/lib/trivial_sso/struct/secret.rb

@@ -0,0 +1,14 @@
+TrivialSso::Secret = Struct.new :sso_secret do
+
+  def sso_secret=(value)
+    # TODO Add something to verify value
+    @sso_secret = value if check_sso_secret(value)
+  end
+
+  private
+
+  def check_sso_secret(value)
+    !value.nil? || !value.empty? || (raise TrivialSso::Error::MissingSecret)
+  end
+
+end

data/lib/trivial_sso/struct/un_wrap.rb

@@ -0,0 +1,54 @@
+TrivialSso::UnWrap = Struct.new :data, :sso_secret do
+
+  attr_reader :userdata, :timestamp
+
+  def unwrap
+    decode_data_and_timestamp
+    userdata
+  end
+
+private
+
+  def userdata=(value)
+    @userdata = (value.has_key?('table') ? value['table'] : value)
+  end
+
+  def timestamp=(time_as_int)
+    if (time_as_int - Time.now.to_i) <= 0
+      # TODO check if we can raise Error::LoginExpired
+      raise TrivialSso::Error::LoginExpired
+    else
+      @timestamp = time_as_int
+    end
+  end
+
+  def decode_data_and_timestamp
+    begin
+      has_data?
+      self.userdata, self.timestamp = \
+        encrypted_message.decrypt_and_verify(data)
+    rescue NoMethodError
+      raise TrivialSso::Error::MissingConfig
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      raise TrivialSso::Error::BadData::Signature
+    rescue ActiveSupport::MessageEncryptor::InvalidMessage
+      raise TrivialSso::Error::BadData::Message
+    end
+  end
+
+  def has_data?
+    if data.nil? || data.empty?
+      raise TrivialSso::Error::BadData::Missing
+    else
+      true
+    end
+  end
+
+  def encrypted_message
+    unless defined? Rails
+      raise TrivialSso::Error::MissingRails
+    end
+    ActiveSupport::MessageEncryptor.new(sso_secret, serializer: JSON)
+  end
+
+end

data/lib/trivial_sso/struct/wrap.rb

@@ -0,0 +1,31 @@
+TrivialSso::Wrap = Struct.new :data, :sso_secret, :expire_time do
+
+  attr_reader :wrap
+
+  def wrap
+    begin
+      encryptor.encrypt_and_sign([data, expire_time]) if sanity_check
+    rescue NoMethodError
+      raise TrivialSso::Error::MissingConfig
+    end
+  end
+
+ private
+
+  def sanity_check
+    sso_secret && check_username || false
+  end
+
+  def encryptor
+    ActiveSupport::MessageEncryptor.new(sso_secret, serializer: JSON)
+  end
+
+  def check_username
+    has_data? || (raise TrivialSso::Error::NoUsernameData)
+  end
+
+  def has_data?
+    data && !(data.username.nil? || data.username.empty?)
+  end
+
+end

data/lib/trivial_sso/version.rb

@@ -1,3 +1,3 @@
 module TrivialSso
-  VERSION = "4.0.0.3"
+  VERSION = "4.0.3"
 end

data/lib/trivial_sso.rb

@@ -1,3 +1,8 @@
+require 'ostruct'
 require "trivial_sso/version"
 require 'trivial_sso/error'
+require 'trivial_sso/struct/secret'
+require 'trivial_sso/struct/un_wrap'
+require 'trivial_sso/struct/wrap'
+require 'trivial_sso/api'
 require 'trivial_sso/login'

data/spec/lib/trivial_sso/api_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'trivial_sso'
+require 'forgery'
+
+# mock out rails app for sso_secret
+module TrivialSso
+  class Application < Rails::Application
+    config.sso_secret = SecureRandom.hex(64)
+  end
+end
+
+describe TrivialSso::Api do
+  let(:sso_secret)  {SecureRandom.hex(64)}
+  let(:expire_time) {(Time.now - 1000).to_i}
+  let(:userdata)    {
+    {
+      'username' => Forgery::Internet.user_name,
+      'groups'   => ['one', 'two']
+    }
+  }
+
+
+  it "gives cookie" do
+    TrivialSso::Api.encode(userdata).should be_kind_of String
+  end
+
+  it "gives data" do
+    data = TrivialSso::Api.decode(TrivialSso::Api.encode(userdata))
+    data['username'].should eq userdata['username']
+    data['groups'].should   eq userdata['groups']
+  end
+
+end
+

data/spec/lib/trivial_sso/login_spec.rb

@@ -0,0 +1,106 @@
+require 'active_support/core_ext'
+require 'trivial_sso'
+require 'forgery'
+require 'securerandom'
+
+require 'rails'
+
+# mock out rails app for sso_secret
+module TrivialSso
+  class Application < Rails::Application
+    config.sso_secret = SecureRandom.hex(64)
+  end
+end
+
+describe TrivialSso::Login do
+  let(:sso_secret) {SecureRandom.hex(64)}
+  let(:userdata) {
+    {
+      'username' => Forgery::Internet.user_name,
+      'groups'   => ['one', 'two']
+    }
+  }
+
+  let(:encode) {
+    TrivialSso::Login.new({secret: sso_secret, data: userdata})
+  }
+
+  let(:decode) {
+    TrivialSso::Login.new({secret: sso_secret, data: encode.wrap})
+  }
+
+  let(:expired_encode) {
+    TrivialSso::Login.new(
+      {data: userdata, secret: sso_secret, expire_time: (Time.now - 1000).to_i}
+    )
+  }
+
+  it "does set the data" do
+    encode.mode.should          eq :wrap
+    encode.data.should          be_kind_of OpenStruct
+    encode.data.username.should eq userdata['username']
+    encode.data.groups.should   eq userdata['groups']
+  end
+
+  it "does create cookie with userdata" do
+    encode.wrap.should be_kind_of String
+  end
+
+  it "should encode and decode" do
+    decode.unwrap.should be_kind_of Hash
+    decode.unwrap.should eq userdata
+  end
+
+  it "should encode and decode as OpenStruct" do
+    decode.struct = true
+    decode.unwrap.should be_kind_of OpenStruct
+    decode.unwrap.should eq OpenStruct.new userdata
+  end
+
+  it "throw exception on missing username" do
+    expect {
+      encode.data = {username: ""}
+      encode.wrap
+    }.to raise_error TrivialSso::Error::NoUsernameData
+  end
+
+  it "throw exception on blank cookie" do
+    expect {
+      decode.data = ""
+      decode.unwrap
+    }.to raise_error TrivialSso::Error::BadData::Missing
+  end
+
+  it "raise exception bad signature when given cookie w/o signature as data source" do
+    expect {
+      decode.data = "BAhbB0kiC2RqbGVlMgY6BkVUbCsHo17iTg"
+      decode.unwrap
+    }.to raise_error TrivialSso::Error::BadData::Signature
+  end
+
+  it "raise exception bad message when given cookie w/o encryped data" do
+    expect {
+      decode.data = "--5b3164f6d1f09fb00d6905d073b18bc45a859b50"
+      decode.unwrap
+    }.to raise_error TrivialSso::Error::BadData::Signature
+  end
+
+  it "raise exception on expired cookie" do
+    expect {
+      decode.data         = expired_encode.wrap
+      decode.unwrap
+    }.to raise_error TrivialSso::Error::LoginExpired
+  end
+
+  it "raises if expire_time not valid" do
+    expect {
+      encode.expire_time = %w(this is bad data)
+    }.to raise_error TrivialSso::Error::BadExpireTime
+  end
+
+  it "uses rails sso if Rails.defined" do
+    encode.secret = Rails.configuration.sso_secret
+    encode.sso_secret.should eq Rails.configuration.sso_secret
+  end
+
+end

data/spec/spec_helper.rb

@@ -18,7 +18,6 @@ Spork.prefork do
   require 'rspec/autorun'
   require 'rspec/mocks'
   require 'factory_girl'
-  require 'perftools'
 
   # Requires supporting ruby files with custom matchers and macros, etc,
   # in spec/support/ and its subdirectories.
@@ -31,14 +30,6 @@ Spork.prefork do
 
     config.order = "random"
 
-    config.before :suite do
-      PerfTools::CpuProfiler.start("#{profile_directory}/rspec_profile")
-    end
-
-    config.after :suite do
-      PerfTools::CpuProfiler.stop
-    end
-
     def profile_directory
       directory = "/tmp/trivial_sso"
       system("mkdir #{directory}") unless Dir.exist? directory

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trivial_sso
 version: !ruby/object:Gem::Version
-  version: 4.0.0.3
+  version: 4.0.3
 platform: ruby
 authors:
 - David J. Lee
@@ -9,34 +9,46 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-03 00:00:00.000000000 Z
+date: 2015-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
 description: |-
@@ -49,17 +61,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
 - lib/generators/templates/README
 - lib/generators/templates/sso_secret.rb
 - lib/generators/trivial_sso/install_generator.rb
+- lib/trivial_sso.rb
+- lib/trivial_sso/api.rb
 - lib/trivial_sso/error.rb
 - lib/trivial_sso/login.rb
+- lib/trivial_sso/struct/secret.rb
+- lib/trivial_sso/struct/un_wrap.rb
+- lib/trivial_sso/struct/wrap.rb
 - lib/trivial_sso/version.rb
-- lib/trivial_sso.rb
-- MIT-LICENSE
-- README.md
-- CHANGELOG.md
-- spec/models/trivial_sso_spec.rb
+- spec/lib/trivial_sso/api_spec.rb
+- spec/lib/trivial_sso/login_spec.rb
 - spec/spec_helper.rb
 - spec/support/deferred_garbage_collection.rb
 homepage: https://github.com/nacengineer/trivial_sso
@@ -72,21 +89,22 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A simple library to help with Single Sign On cookies
 test_files:
-- spec/models/trivial_sso_spec.rb
+- spec/lib/trivial_sso/api_spec.rb
+- spec/lib/trivial_sso/login_spec.rb
 - spec/spec_helper.rb
 - spec/support/deferred_garbage_collection.rb

data/spec/models/trivial_sso_spec.rb

@@ -1,66 +0,0 @@
-require 'active_support/core_ext'
-
-require 'trivial_sso'
-require 'forgery'
-require 'securerandom'
-
-describe TrivialSso do
-
-  def before
-    # Stub out our Rails config so we can test things properly.
-    Rails.stubs(:configuration).returns(Rails::Application::Configuration.allocate)
-    Rails.configuration.sso_secret = SecureRandom.hex(64)
-    @user_name      = Forgery::Internet.user_name
-    @data           = Forgery::LoremIpsum.words(20)
-    @userdata       = {'username' => @user_name, 'data' => @data}
-    @expired_cookie = TrivialSso::Login.cookie(
-      {'username' => 'testor'}, 2.seconds.ago
-    )
-  end
-
-  it "does create cookie with userdata" do
-    TrivialSso::Login.cookie(@userdata).should_not be_nil
-  end
-
-  # def test_create_cookie_and_decode_it
-  #   mycookie = TrivialSso::Login.cookie(@userdata)
-  #   data     = TrivialSso::Login.decode_cookie(mycookie)
-  #   assert_equal data['data'],  @data
-  # end
-
-  # def test_throw_exception_on_missing_username
-  #   assert_raise TrivialSso::Error::NoUsernameCookie do
-  #     mycookie = TrivialSso::Login.cookie("")
-  #   end
-  # end
-
-  # def test_expire_date_exists
-  #   # in a full rails environment, this will return an ActiveSupport::TimeWithZone
-  #   assert TrivialSso::Login.expire_date.is_a?(Time),
-  #     "proper Time object not returned"
-  # end
-
-  # def test_expire_date_is_in_future
-  #   assert (DateTime.now < TrivialSso::Login.expire_date),
-  #     "Expire date is in the past - cookie will expire immediatly."
-  # end
-
-  # def test_raise_exception_on_blank_cookie
-  #   assert_raise TrivialSso::Error::MissingCookie do
-  #     TrivialSso::Login.decode_cookie("")
-  #   end
-  # end
-
-  # def test_raise_exception_on_bad_cookie
-  #   assert_raise TrivialSso::Error::BadCookie do
-  #     TrivialSso::Login.decode_cookie("BAhbB0kiC2RqbGVlMgY6BkVUbCsHo17iTg")
-  #   end
-  # end
-
-  # def test_raise_exception_on_expired_cookie
-  #   assert_raise TrivialSso::Error::LoginExpired do
-  #     TrivialSso::Login.decode_cookie(@expired_cookie)
-  #   end
-  # end
-
-end