active_url 0.1.4

data/spec/callbacks_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe ActiveUrl do
+  before(:each) do
+    ActiveUrl::Config.stub!(:secret).and_return("secret")
+  end
+
+  context "instance with callbacks" do
+    before(:all) do
+      class ::Registration < ActiveUrl::Base  
+        attribute :email
+        after_save :send_registration_email
+      end
+    end
+    
+    after(:all) do
+      Object.send(:remove_const, "Registration")
+    end
+    
+    before(:each) do
+      @registration = Registration.new(:email => "email@example.com")
+      @registration.stub!(:valid?).and_return(true)
+    end
+    
+    it "should not run the callback when saved if the instance is invalid" do
+      @registration.stub!(:valid?).and_return(false)
+      @registration.should_not_receive(:send_registration_email)
+      @registration.save
+    end
+    
+    it "should run the callback when saved if the instance is valid" do
+      @registration.should_receive(:send_registration_email)
+      @registration.save
+    end
+    
+    it "should not run the callback when found from its ID" do
+      @registration.stub!(:send_registration_email).and_return(true)
+      @registration.save
+      @found = Registration.new
+      Registration.should_receive(:new).and_return(@found)
+      @found.should_not_receive(:send_registration_email)
+      Registration.find(@registration.id)
+    end
+  end
+end

data/spec/crypto_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe ActiveUrl do
+  before(:each) do
+    ActiveUrl::Config.stub!(:secret).and_return("secret")
+  end
+  
+  describe "crypto" do
+    it "should raise ArgumentError when no secret is set" do
+      ActiveUrl::Config.stub!(:secret).and_return(nil)
+      lambda { ActiveUrl::Crypto.encrypt("clear") }.should raise_error(ArgumentError)
+    end
+  
+    it "should decode what it encodes" do
+      ActiveUrl::Crypto.decrypt(ActiveUrl::Crypto.encrypt("clear")).should == "clear"
+    end
+  
+    it "should always yield URL-safe output characters" do
+      url_safe = /^[\w\-]*$/
+      (1..20).each do |n|
+        clear = (0...8).inject("") { |string, n| string << rand(255).chr } # random string
+        cipher = ActiveUrl::Crypto.encrypt(clear)
+        cipher.should =~ url_safe
+      end
+    end
+  end
+end

data/spec/instance_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe ActiveUrl do
+  before(:each) do
+    ActiveUrl::Config.stub!(:secret).and_return("secret")
+  end
+  
+  context "instance" do
+    before(:each) do
+      @url = ActiveUrl::Base.new
+    end
+    
+    it "should have nil id" do
+      @url.id.should be_nil
+    end
+  
+    it "should be a new_record" do
+      @url.should be_new_record
+    end
+    
+    it "should be saveable" do
+      @url.save.should be_true
+    end
+  
+    context "after saving" do
+      before(:each) do
+        @url.save
+      end
+    
+      it "should have an id" do
+        @url.id.should_not be_blank
+      end
+      
+      it "should not be a new record" do
+        @url.should_not be_new_record
+      end
+    end
+  end
+  
+  context "derived" do
+    before(:all) do  
+      class ::DerivedClass < ActiveUrl::Base
+        attribute :foo, :bar
+        attribute :baz, :accessible => true
+        attr_accessible :bar
+          
+        attr_accessor :x, :y
+        attr_accessible :y
+      end
+    end
+    
+    after(:all) do
+      Object.send(:remove_const, "DerivedClass")
+    end
+    
+    context "instance" do
+      it "should have individually accessible attribute readers" do
+        @url = DerivedClass.new
+        [ :foo, :bar, :baz ].each { |reader| @url.public_methods.map(&:to_sym).should include(reader) }
+      end
+
+      it "should have individually accessible attribute setters" do
+        @url = DerivedClass.new
+        [ :foo=, :bar=, :baz= ].each { |setter| @url.public_methods.map(&:to_sym).should include(setter) }
+      end
+      
+      it "should not mass-assign attributes by default" do
+        @url = DerivedClass.new(:foo => "foo")
+        @url.foo.should be_nil
+      end
+    
+      it "should mass-assign attributes declared as attr_accessible" do
+        @url = DerivedClass.new(:bar => "bar")
+        @url.bar.should == "bar"
+      end
+    
+      it "should mass-assigned attributes with :accessible specified on declaration" do
+        @url = DerivedClass.new(:baz => "baz")
+        @url.baz.should == "baz"
+      end
+
+      it "should not mass-assign virtual attributes by default" do
+        @url = DerivedClass.new(:x => "x")
+        @url.x.should be_nil
+      end
+    
+      it "should mass-assign its accessible virtual attributes" do
+        @url = DerivedClass.new(:y => "y")
+        @url.y.should == "y"
+      end
+      
+      it "should know its mass-assignable attribute names" do
+        @url = DerivedClass.new
+        [ :bar, :baz, :y ].each { |name| @url.accessible_attributes.should     include(name) }
+        [ :foo, :x       ].each { |name| @url.accessible_attributes.should_not include(name) }
+      end
+      
+      it "should know its attribute names" do
+        @url = DerivedClass.new
+        [ :foo, :bar, :baz ].each { |name| @url.attribute_names.should     include(name) }
+        [ :x, :y           ].each { |name| @url.attribute_names.should_not include(name) }
+      end
+      
+      context "equality" do
+        before(:all) do
+          class ::OtherClass < DerivedClass
+          end
+        end
+        
+        after(:all) do
+          Object.send(:remove_const, "OtherClass")
+        end
+        
+        it "should be based on class and attributes only" do
+          @url  = DerivedClass.new(:bar => "bar", :baz => "baz")
+          @url2 = DerivedClass.new(:bar => "bar", :baz => "baz")
+          @url3 = DerivedClass.new(:bar => "BAR", :baz => "baz")
+          @url4 =   OtherClass.new(:bar => "bar", :baz => "baz")
+          @url.should == @url2
+          @url.should_not == @url3
+          @url.should_not == @url4
+        end
+      end
+    end
+    
+    context "class" do
+      it "should know its mass-assignable attribute names" do
+        [ :bar, :baz, :y ].each { |name| DerivedClass.accessible_attributes.should     include(name) }
+        [ :foo, :x       ].each { |name| DerivedClass.accessible_attributes.should_not include(name) }
+      end
+      
+      it "should know its attribute names" do
+        [ :foo, :bar, :baz ].each { |name| DerivedClass.attribute_names.should     include(name) }
+        [ :x, :y           ].each { |name| DerivedClass.attribute_names.should_not include(name) }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'active_url'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/validations_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe ActiveUrl do
+  before(:each) do
+    ActiveUrl::Config.stub!(:secret).and_return("secret")
+  end
+  
+  context "instance with validations" do
+    before(:all) do
+      class ::Registration < ActiveUrl::Base  
+        attribute :name, :email, :password, :age, :accessible => true
+        validates_presence_of :name
+        validates_format_of :email, :with => /^[\w\.=-]+@[\w\.-]+\.[a-zA-Z]{2,4}$/ix
+        validates_length_of :password, :minimum => 8
+        validates_numericality_of :age
+      end
+    end
+    
+    after(:all) do
+      Object.send(:remove_const, "Registration")
+    end
+    
+    context "when invalid" do
+      before(:each) do
+        @registration = Registration.new(:email => "user @ example . com", :password => "short", :age => "ten")
+      end
+      
+      it "should not validate" do
+        @registration.should_not be_valid
+      end
+  
+      it "should not save" do
+        @registration.save.should_not be_true
+        @registration.id.should be_nil
+      end
+
+      it "should raise ActiveUrl::InvalidRecord when saved with bang" do
+        lambda { @registration.save! }.should raise_error(ActiveUrl::RecordInvalid)
+      end
+      
+      context "and saved" do
+        before(:each) do
+          @registration.save
+        end
+
+        it "should have errors" do
+          @registration.errors.should_not be_empty
+        end
+        
+        it "should validate presence of an attribute" do
+          @registration.errors[:name].should_not be_blank
+        end
+        
+        it "should validate format of an attribute" do
+          @registration.errors[:email].should_not be_blank
+        end
+        
+        it "should validate length of an attribute" do
+          @registration.errors[:password].should_not be_nil
+        end
+        
+        it "should validate numericality of an attribute" do
+          @registration.errors[:age].should_not be_nil
+        end
+      end
+    end
+    
+    context "when valid" do
+      before(:each) do
+        @registration = Registration.new(:name => "John Doe", :email => "user@example.com", :password => "password", :age => "10")
+      end
+      
+      it "should validate" do
+        @registration.should be_valid
+      end
+      
+      context "and saved" do
+        before(:each) do
+          @registration.save
+        end
+        
+        it "should have an id" do
+          @registration.id.should_not be_blank
+        end
+        
+        it "should have a param equal to its id" do
+          @registration.id.should == @registration.to_param
+        end
+        
+        context "and re-found by its class" do
+          before(:each) do
+            @found = Registration.find(@registration.id)
+          end
+          
+          it "should exist" do
+            @found.should_not be_nil
+          end
+          
+          it "should have the same id" do
+            @found.id.should == @registration.id
+          end
+          
+          it "should have the same attributes" do
+            @found.attributes.should == @registration.attributes
+          end
+          
+          it "should be valid" do
+            @found.should be_valid
+          end
+        end
+        
+        context "and subsequently made invalid" do
+          before(:each) do
+            @registration.password = "short"
+            @registration.stub!(:valid?).and_return(true)
+            @registration.save
+          end
+                              
+          it "should not be found by its class" do
+            @registration.id.should_not be_blank
+            lambda { Registration.find(@registration.id) }.should raise_error(ActiveUrl::RecordNotFound)
+          end
+        end
+      end
+    end
+    
+    it "should raise ActiveUrl::RecordNotFound if id does not exist" do
+      lambda { Registration.find("blah") }.should raise_error(ActiveUrl::RecordNotFound)
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: active_url
+version: !ruby/object:Gem::Version 
+  version: 0.1.4
+platform: ruby
+authors: 
+- Matthew Hollingworth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-10 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "      ActiveUrl enables the storing of a model in an encrypted URL. It facilitates implementation\n      of secret URLs for user (e.g. feed URLs) that can be accessed without logging in, and URLs\n      for confirming the email address of a new user.\n"
+email: mdholling@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION.yml
+- active_url.gemspec
+- lib/active_url.rb
+- lib/active_url/base.rb
+- lib/active_url/belongs_to.rb
+- lib/active_url/callbacks.rb
+- lib/active_url/configuration.rb
+- lib/active_url/crypto.rb
+- lib/active_url/errors.rb
+- lib/active_url/validations.rb
+- rails/init.rb
+- spec/belongs_to_spec.rb
+- spec/callbacks_spec.rb
+- spec/crypto_spec.rb
+- spec/instance_spec.rb
+- spec/spec_helper.rb
+- spec/validations_spec.rb
+has_rdoc: true
+homepage: http://github.com/mholling/active_url
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Rails library for generating secret URLs.
+test_files: 
+- spec/belongs_to_spec.rb
+- spec/callbacks_spec.rb
+- spec/crypto_spec.rb
+- spec/instance_spec.rb
+- spec/spec_helper.rb
+- spec/validations_spec.rb