make_exportable 1.0.0

data/spec/make_exportable/make_exportable_spec.rb

@@ -0,0 +1,510 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Make Exportable" do
+
+  before(:each) do
+    clean_database!
+  end
+
+  describe MakeExportable do
+
+    # For simply having MakeExportable loaded as a gem/plugin
+    describe "mattr_accessor :exportable_classes" do
+
+      it "should be a hash" do
+        MakeExportable.exportable_classes.class.should == Hash
+      end
+
+      it "should be readable and writable" do
+        MakeExportable.exportable_classes[:testkey] = 'testvalue'
+        MakeExportable.exportable_classes[:testkey].should == 'testvalue'
+        MakeExportable.exportable_classes.delete(:testkey)
+      end
+    end
+
+    describe "mattr_accessor :exportable_formats" do
+
+      it "should be a hash" do
+        MakeExportable.exportable_classes.class.should == Hash
+      end
+
+      it "should be readable and writable" do
+        MakeExportable.exportable_formats[:testkey] = 'testvalue'
+        MakeExportable.exportable_formats[:testkey].should == 'testvalue'
+        MakeExportable.exportable_formats.delete(:testkey)
+      end
+
+      it "should contain keys for the supported format types" do
+        MakeExportable.exportable_formats.should_not be_nil
+        MakeExportable.exportable_formats.key?(:csv ).should be_true
+        MakeExportable.exportable_formats.key?(:xls ).should be_true
+        MakeExportable.exportable_formats.key?(:html).should be_true
+        MakeExportable.exportable_formats.key?(:json).should be_true
+        MakeExportable.exportable_formats.key?(:tsv ).should be_true
+        MakeExportable.exportable_formats.key?(:xml ).should be_true
+      end
+
+      it "should have the correct format class as a value for each key" do
+        MakeExportable.exportable_formats[:csv ].should == MakeExportable::CSV
+        MakeExportable.exportable_formats[:xls ].should == MakeExportable::Excel
+        MakeExportable.exportable_formats[:html].should == MakeExportable::HTML
+        MakeExportable.exportable_formats[:json].should == MakeExportable::JSON
+        MakeExportable.exportable_formats[:tsv ].should == MakeExportable::TSV
+        MakeExportable.exportable_formats[:xml ].should == MakeExportable::XML
+      end
+
+    end
+
+    describe "extenstions to ActiveRecord's class methods" do
+
+      it "should include MakeExportable's ActiveRecordBaseMethods" do
+        if ActiveRecord::VERSION::MAJOR >= 3
+          ActiveRecord::Base.methods.include?(:exportable?).should be_true
+          ActiveRecord::Base.methods.include?(:make_exportable).should be_true
+        else
+          ActiveRecord::Base.methods.include?('exportable?').should be_true
+          ActiveRecord::Base.methods.include?('make_exportable').should be_true
+        end
+      end
+
+    end
+
+
+    # Once classes add MakeExportable's functionality
+    describe "classes declaring make_exportable" do
+
+      before(:each) do
+        class User
+          make_exportable
+        end
+      end
+
+      it "should be included in MakeExportable.exportable_tables" do
+        MakeExportable.exportable_classes['User'].should == User
+      end
+
+      it "should have MakeExportable's ClassMethods" do
+        if ActiveRecord::VERSION::MAJOR >= 3
+          User.methods.include?(:exportable?).should be_true
+          User.methods.include?(:to_export).should be_true
+          User.methods.include?(:get_export_data).should be_true
+          User.methods.include?(:create_report).should be_true
+        else
+          User.methods.include?("exportable?").should be_true
+          User.methods.include?("to_export").should be_true
+          User.methods.include?("get_export_data").should be_true
+          User.methods.include?("create_report").should be_true
+        end
+      end
+
+      it "should not expose MakeExportable's ClassMethods which are private" do
+        if ActiveRecord::VERSION::MAJOR >= 3
+          User.methods.include?(:find_export_data).should be_false
+          User.methods.include?(:map_export_data).should be_false
+          User.methods.include?(:validate_export_format).should be_false
+          User.methods.include?(:validate_export_data_lengths).should be_false
+        else
+          User.methods.include?("find_export_data").should be_false
+          User.methods.include?("map_export_data").should be_false
+          User.methods.include?("validate_export_format").should be_false
+          User.methods.include?("validate_export_data_lengths").should be_false
+        end
+      end
+
+      it "should have MakeExportable's InstanceMethods" do
+        if ActiveRecord::VERSION::MAJOR >= 3
+          User.instance_methods.include?(:export_attribute).should be_true
+        else
+          User.instance_methods.include?("export_attribute").should be_true
+        end
+      end
+
+      it "should have an inheritable class accessor for exportable_options" do
+        if ActiveRecord::VERSION::MAJOR >= 3
+          User.instance_methods.include?(:exportable_options).should be_true
+        else
+          User.instance_methods.include?("exportable_options").should be_true
+        end
+      end
+
+      describe "dynamically-named methods" do
+
+        describe 'create_#{format}_report' do
+
+          MakeExportable.exportable_formats.map do |format, v|
+            it "should define the method create_#{format}_report" do
+              User.should_receive(:create_report).with(format.to_s)
+              User.send("create_#{format}_report")
+            end
+          end
+
+          it "should return NoMethodError if the format is not supported" do
+            lambda do
+              User.create_xyz_report
+            end.should raise_error(NoMethodError)
+          end
+
+        end
+
+        describe 'to_#{format}_export' do
+
+          MakeExportable.exportable_formats.map do |format, v|
+            it "should define the method to_#{format}_export" do
+              User.should_receive(:to_export).with(format.to_s)
+              User.class_eval("to_#{format}_export")
+            end
+          end
+
+          it "should return NoMethodError if the format is not supported" do
+            lambda do
+              User.to_xyz_export
+            end.should raise_error(NoMethodError)
+          end
+
+        end
+
+      end
+
+      describe "not passing in options" do
+
+        it "should set default values for key options" do
+          User.exportable_options.keys.map(&:to_s).sort.should == ["columns", "formats", "scopes"]
+        end
+
+        it "should set :columns to all database columns" do
+          User.exportable_options[:columns].should == [:id, :first_name, :last_name, :password, :email, :is_admin, :created_at, :updated_at]
+        end
+
+        it "should set :formats to all supported formats" do
+          User.exportable_options[:formats].map(&:to_s).sort.should == ["csv", "html", "json", "tsv", "xls", "xml"]
+        end
+
+        it "should set :scopes to an empty array" do
+          User.exportable_options[:scopes].should == []
+        end
+
+      end
+
+      describe "passing in options" do
+
+        it "should toss out invalid options" do
+
+          class Post < ActiveRecord::Base
+            make_exportable :nonsense => "this should not be included", :offset => 20
+          end
+
+          # valid_options = [:as, :only, :except, :scopes, :conditions, :order, :include,
+          #                  :group, :having, :limit, :offset, :joins]
+          Post.exportable_options.include?(:nonsense).should be_false
+          Post.exportable_options.include?(:offset).should be_true
+        end
+
+        describe ":only/:except options" do
+
+          it "should not appear in exportable_options" do
+            # these get removed and converted into :columns
+            class Post < ActiveRecord::Base
+              make_exportable :only => [:this, :that, :another], :except => [:title]
+            end
+            Post.exportable_options.include?(:only).should be_false
+            Post.exportable_options.include?(:except).should be_false
+          end
+
+          it "should allow column names to be either strings or symbols" do
+            class Post < ActiveRecord::Base
+              make_exportable :only => ["full_name", :symbol_method]
+            end
+            Post.exportable_options[:columns].should == [:full_name, :symbol_method]
+          end
+
+          it "should allow a single column name or an array of names" do
+            class Post < ActiveRecord::Base
+              make_exportable :only => "full_name"
+            end
+            Post.exportable_options[:columns].should == [:full_name]
+          end
+
+          # unique for :only option
+          it "should allow attributes/methods which are not database columns" do
+
+            class Post < ActiveRecord::Base
+              make_exportable :only => ["a_method_name", "another_method"]
+            end
+
+            Post.exportable_options[:columns].should == [:a_method_name, :another_method]
+
+          end
+
+          it "should replace the default columns saved in exportable_options[:columns]" do
+
+            class Post < ActiveRecord::Base
+              make_exportable :only => ["a_method_name", "another_method"]
+            end
+
+            Post.exportable_options[:columns].should == [:a_method_name, :another_method]
+          end
+
+          # unless we add a check for this
+          it "should not try to catch bogus attribute/method names" do
+            class Post < ActiveRecord::Base
+              make_exportable :only => ["full_name", "another_method"]
+            end
+            Post.exportable_options[:columns].should == [:full_name, :another_method]
+          end
+
+          # unique for :except option
+          it "should subtract from the default columns saved in exportable_options[:columns]" do
+
+            class Post < ActiveRecord::Base
+              make_exportable :except => [:created_at, :updated_at]
+            end
+
+            Post.exportable_options[:columns].should == [:id, :title, :content, :approved]
+          end
+
+          it "should ignore bogus attribute/method names" do
+            class Post < ActiveRecord::Base
+              make_exportable :except => [:created_at, :updated_at, :bogus]
+            end
+            Post.exportable_options[:columns].should == [:id, :title, :content, :approved]
+          end
+
+        end
+
+        describe ":as option" do
+
+          it "should not appear in exportable_options" do
+            class Post < ActiveRecord::Base
+              make_exportable :as => [:csv, "xml"]
+            end
+            Post.exportable_options.include?(:as).should be_false
+          end
+
+          it "should allow format names to be either strings or symbols" do
+            class Post < ActiveRecord::Base
+              make_exportable :as => [:csv, "xml"]
+            end
+            Post.exportable_options[:formats].map(&:to_s).sort.should == ["csv", "xml"]
+          end
+
+          it "should allow a single format name or an array of names" do
+            class Post < ActiveRecord::Base
+              make_exportable :as => :json
+            end
+            Post.exportable_options[:formats].should == [:json]
+          end
+
+          it "should ignore formats not in the supported formats" do
+            class Post < ActiveRecord::Base
+              make_exportable :as => [:csv, "unsupported"]
+            end
+            Post.exportable_options[:formats].should == [:csv]
+          end
+
+          it "should raise an error if only unsupported formats are passed in" do
+            lambda do
+              class Post < ActiveRecord::Base
+                make_exportable :as => "unsupported"
+              end
+            end.should raise_error(MakeExportable::FormatNotFound)
+          end
+        end
+
+        describe ":scopes option" do
+          it "should be saved unchanged in exportable_options[:scopes]" do
+            Post.class_eval("make_exportable :scopes => [:scope1, :scope2]")
+            Post.exportable_options[:scopes].should == [:scope1, :scope2]
+          end
+        end
+
+        describe "finder options" do
+          [:conditions, :order, :include, :group, :having, :limit, :offset, :joins].each do |opt|
+            it "should save :#{opt} unchanged in exportable_options[:#{opt}]" do
+              Post.class_eval("make_exportable :#{opt} => 'accepts anything trusting the user'")
+              Post.exportable_options[opt].should == "accepts anything trusting the user"              
+            end
+          end
+        end
+
+      end
+
+    end
+
+    describe "MakeExportable::ClassMethods" do
+
+      before(:each) do
+        class User
+          make_exportable
+        end
+        clean_database!
+        User.create(:first_name => "user_1", :last_name => "Doe", :created_at => Time.at(0), :updated_at => Time.at(0))
+        User.create(:first_name => "user_2", :last_name => "Doe", :created_at => Time.at(0), :updated_at => Time.at(0))
+      end
+
+      describe "exportable?" do
+
+        it "should be false for regular ActiveRecord classes" do
+          Unexportable.exportable?.should be_false
+        end
+
+        it "should be true for classes that call make_exportable" do
+          User.exportable?.should be_true
+        end
+
+        it "should be true when the argument value is an allowed format for this class" do
+          User.exportable?("csv").should be_true
+        end
+
+        it "should be false when the argument value is not an allowed format for this class" do
+          User.exportable?("unsupported").should be_false
+        end
+
+      end
+
+      describe "to_export" do
+
+        it "should use default headers if no :header option is sent"
+        
+        it "should use :headers option for headers if sent"
+        
+        it "should use no headers if :headers is false"
+
+      end
+
+      describe "get_export_data" do
+
+        context "scopes and find options" do
+          # Test how :scopes and find options are merged and applied
+          # (testing the private method :find_export_data)
+          it "should chainable on named_scopes" do
+            User.a_limiter.get_export_data(:only => [:first_name, :last_name]).should == [["first_name", "last_name"],["user_1", "Doe"]]
+          end
+
+          it "should allow a scope to be sent" do
+            User.get_export_data(:only => [:first_name, :last_name], :scopes => ['a_limiter']).should == [["first_name", "last_name"], ["user_1", "Doe"]]
+          end
+
+          it "should allow multiple scopes to be sent" do
+            User.get_export_data(:only =>[:first_name, :last_name], :scopes => ['a_limiter', "order_by"]).should == [["first_name", "last_name"], ["user_2", "Doe"]]
+          end
+
+          it "should find records using :conditions option" do
+            if ActiveRecord::VERSION::MAJOR < 3
+              User.get_export_data(:only => [:first_name, :last_name], :conditions => {:first_name => "user_1"} ).should == [["first_name", "last_name"], ["user_1", "Doe"]]
+            end
+          end
+
+          it "should sort records using :order option" do
+            if ActiveRecord::VERSION::MAJOR < 3
+              User.get_export_data(:only => [:first_name, :last_name], :order => "id DESC").should == [["first_name", "last_name"], ["user_2", "Doe"], ["user_1", "Doe"]]
+            end
+          end
+
+          it "should limit records using :limit option" do
+            if ActiveRecord::VERSION::MAJOR < 3
+              User.get_export_data(:only => [:first_name, :last_name], :limit => 1, :order => "id ASC" ).should == [["first_name", "last_name"], ["user_1", "Doe"]]
+            end
+          end
+
+          # TODO: Test how :scopes and find options get merged when there are default options
+          
+        end
+        
+        context "column selection" do
+          # Test how :only/:except are merged and selected
+          # (testing the private method :map_export_data)
+          it "should export the default columns by default" do
+            time = User.first.created_at.to_s
+            User.get_export_data().should == [["id", "first_name", "last_name", "password", "email", "is_admin", "created_at", "updated_at"], ["1", "user_1", "Doe", "", "", "false", Time.at(0).to_s, Time.at(0).to_s], ["2", "user_2", "Doe", "", "", "false", Time.at(0).to_s, Time.at(0).to_s]]
+          end
+
+          it "should export only the columns given by :only" do
+            User.get_export_data(:only => [:first_name, :last_name]).should == [["first_name", "last_name"], ["user_1", "Doe"], ["user_2", "Doe"]]
+          end
+
+          it "should export the default columns minus those given by :except" do
+            User.get_export_data(:except => [:id, :created_at, :updated_at, :password, :is_admin]).should ==  [["first_name", "last_name", "email"], ["user_1", "Doe", ""], ["user_2", "Doe", ""]]
+          end
+
+          it "should raise an error if no columns are passed" do
+            lambda do
+              User.nothing.get_export_data(:except =>["id", "first_name", "last_name", "password", "email", "is_admin", "created_at", "updated_at"])
+            end.should raise_error(MakeExportable::ExportFault)
+          end
+
+          # TODO: Test how :only/:except get merged when there are default options
+
+        end
+        
+      end
+
+      describe "create_report" do
+
+        it "should raise an FormatNotFound if the format is not supported" do
+          lambda do
+            User.create_report("NONSUPPORTED", "")
+          end.should raise_error(MakeExportable::FormatNotFound)
+        end
+
+        it 'should export an array of header and array of arrays of rows in the specified format' do
+          User.create_report("csv", [[ "data", 'lovely data'],["", "more lovely data"]], :headers => ["Title", "Another Title"]).should == ["Title,Another Title\ndata,lovely data\n\"\",more lovely data\n", "text/csv; charset=utf-8; header=present"]
+        end
+
+        it 'should export array of arrays of rows in the specified format if header is set to true with header set as present' do
+          User.create_report("csv", [["Title", "Another Title"],[ "data", 'lovely data'],["", "more lovely data"]], :headers => true).should == ["Title,Another Title\ndata,lovely data\n\"\",more lovely data\n", "text/csv; charset=utf-8; header=present"]
+        end
+
+        it 'should export array of arrays of rows in the specified format if header is set to false' do
+          User.create_report("csv", [[ "data", 'lovely data'],["", "more lovely data"]], :headers => false).should == ["data,lovely data\n\"\",more lovely data\n", "text/csv; charset=utf-8; header=absent"]
+        end
+
+        it "should raise an ExportFault if the datasets are not all the same size" do
+          lambda do
+            User.create_report("xml", [[ "data", 'lovely data'],["more lovely data"]], :headers =>["Title", "Another Title"])
+          end.should raise_error(MakeExportable::ExportFault)
+        end
+
+      end
+
+    end
+
+    describe "MakeExportable::InstanceMethods" do
+
+      describe "#export_attribute" do
+
+        before(:each) do
+          class User
+            make_exportable
+          end
+          @user = User.create(:first_name => "Carl", :last_name => "Joans")
+        end
+
+        it "should return attribute values" do
+          @user.export_attribute('is_admin').should == "false"
+        end
+
+        it 'should allow #{method}_export to override the original method'  do
+          class User < ActiveRecord::Base
+            def is_admin_export
+              return "I'm not an Admin I'm a monkey"
+            end
+          end
+          @user.export_attribute('is_admin').should == "I'm not an Admin I'm a monkey"
+        end
+
+        # TODO: Would it be better behavior to raise an error?
+        it "should return an empty string if the attribute doesn't exist" do
+          @user.export_attribute('ful_name').should == ""
+        end
+
+        it "should be able to call methods as attributes during exporting" do
+          @user.export_attribute('full_name').should == "Carl Joans"
+        end
+
+      end
+
+    end
+
+  end
+
+end