stockor-core 0.2

data/test/concerns/attr_with_default_test.rb

@@ -0,0 +1,45 @@
+require_relative '../test_helper'
+
+class AttrAccessorWithDefaultTest < Skr::TestCase
+
+    Shared = Struct.new(:value)
+
+    class AttrTestClass
+        include Skr::Concerns::AttrAccessorWithDefault
+        attr_accessor_with_default :as_proc, Proc.new{ 42 }
+        attr_accessor_with_default :non_copying, ->{ "default string" }
+        attr_accessor_with_default :shared, Shared.new('default')
+        attr_accessor_with_default :non_shared, ->{ Shared.new('default') }
+    end
+
+    def test_access
+        a = AttrTestClass.new
+        b = AttrTestClass.new
+
+        assert_equal 42, b.as_proc
+
+        assert_equal "default string", b.non_copying
+
+        b.non_copying = "A new string"
+
+        assert_equal "default string", a.non_copying
+        a.non_copying = "third value"
+        assert_equal "A new string", b.non_copying
+
+
+        assert_equal "default", a.shared.value
+        assert_equal "default", b.shared.value
+
+        a.shared.value = "a new value"
+
+        assert_equal "a new value", a.shared.value
+        assert_equal "a new value", b.shared.value
+
+        a.non_shared.value = "a new value"
+        assert_equal "a new value", a.non_shared.value
+        assert_equal "default", b.non_shared.value
+
+    end
+
+
+end

data/test/concerns/code_identifier_test.rb

@@ -0,0 +1,46 @@
+require_relative '../test_helper'
+
+
+class CodeIdentifierTest < Skr::TestCase
+
+
+    class CodeIdentifierTestModel
+        class_attribute :blocks
+        attr_accessor :code
+
+        include Skr::Concerns::CodeIdentifier
+
+        def self.before_validation( opts={}, &block )
+            self.blocks||=[]
+            self.blocks.push( block )
+        end
+
+        def self.validates( *opts )
+        end
+
+        def run_validations
+            self.class.blocks.each{ |b| self.instance_eval(&b) }
+        end
+
+        def [](name)
+            :name == name ? 'A Long String of Nonsense' : ''
+        end
+
+        has_code_identifier :from => :name
+    end
+
+    def test_that_it_uppercases
+        ci = CodeIdentifierTestModel.new
+        ci.code='test'
+        ci.run_validations
+        assert_equal 'TEST', ci.code
+    end
+
+    def test_that_it_generates
+        ci = CodeIdentifierTestModel.new
+        ci.run_validations
+        assert ci.code.present?, "Code wasn't auto-generated"
+        assert_equal 'ALOSTOFNON',  ci.code
+    end
+
+end

data/test/concerns/export_associations_test.rb

@@ -0,0 +1,7 @@
+require_relative '../test_helper'
+
+
+class ExportAssociationsTest < Skr::TestCase
+
+
+end

data/test/concerns/export_methods_test.rb

@@ -0,0 +1,31 @@
+require_relative '../test_helper'
+
+
+class ExportMethodsTest < Skr::TestCase
+
+    def teardown
+        GlPosting.send( :remove_method, :gl_transaction_description ) if GlPosting.new.respond_to?( :gl_transaction_description )
+        GlAccount.exported_methods = {}
+    end
+
+    def test_simple_delegation
+        refute GlPosting.new.respond_to? :gl_transaction_description
+
+        GlPosting.send :delegate_and_export, "gl_transaction_description"
+
+        glp = GlPosting.new
+        assert glp.respond_to? :gl_transaction_description, "Didn't add gl_transaction_description method"
+        assert_nil glp.gl_transaction_description
+        glp.build_gl_transaction( description: "test123" )
+        assert_equal "test123", glp.gl_transaction_description
+        assert GlPosting.has_exported_method?( :gl_transaction_description, nil ), "Didn't export method"
+    end
+
+    def test_dependancy_calculation
+        GlPosting.send :delegate_and_export, "gl_transaction_description"
+        GlPosting.send :delegate_and_export, "gl_transaction_notes", optional: false
+        assert_equal [:gl_transaction], GlPosting.exported_method_dependancies([])
+        assert_equal [:gl_transaction], GlPosting.exported_method_dependancies(['gl_transaction_description']).sort
+    end
+
+end

data/test/concerns/export_scope_test.rb

@@ -0,0 +1,16 @@
+require_relative '../test_helper'
+
+class ExportScopeTest < Skr::TestCase
+
+
+    def test_method_creation
+        GlPosting.send( :remove_method, :big_query ) if GlPosting.respond_to?( :account_name )
+    end
+
+    def test_scope_method_creation
+        refute GlPosting.respond_to?(:big_query)
+        GlPosting.send( :export_scope, :big_query, ->{} )
+        assert GlPosting.respond_to?(:big_query)
+    end
+
+end

data/test/concerns/exported_limits_test.rb

@@ -0,0 +1,47 @@
+require_relative '../test_helper'
+
+
+class ExportedLimitsTest < Skr::TestCase
+
+    class LimitsTestingModel
+
+        include Skr::Concerns::ExportScope
+        include Skr::Concerns::ExportMethods
+
+        def self.scope(name, query)# act like ActiveRecord model
+        end
+
+        def secret_method( name, query )
+        end
+
+        def test_method( name, query )
+        end
+
+        export_methods :test_method, limit: lambda{ | user, type, name |
+            user == 'anon'
+        }
+
+        export_scope :admin_data, lambda{ | param |
+            param
+        }, limit: :only_admins
+
+        export_methods :secret_method, limit: :only_admins
+
+
+        def self.only_admins( user, type, name )
+            return user == 'admin'
+        end
+
+    end
+
+    def test_limits
+        assert LimitsTestingModel.has_exported_method?( 'test_method', 'anon' ), "anyone can retrieve no_limit data"
+
+        assert LimitsTestingModel.has_exported_scope?( 'admin_data', 'admin' ), "Admins can retrieve admin data"
+        refute LimitsTestingModel.has_exported_scope?( 'admin_data', 'non-admin' ), "Non-Admin cannot retrieve admin data"
+
+        assert LimitsTestingModel.has_exported_method?( 'secret_method', 'admin' ), "Public can retrieve public data"
+        refute LimitsTestingModel.has_exported_method?( 'secret_method', 'unk' ), "User must be admin to retrieve public data"
+    end
+
+end

data/test/concerns/json_attribute_access_test.rb

@@ -0,0 +1,27 @@
+require_relative '../test_helper'
+
+
+class JsonAttributeAccessTest < Skr::TestCase
+
+    def teardown
+        GlAccount.whitelisted_json_attributes = {}
+        GlAccount.blacklisted_json_attributes = {:updated_at=>{}, :created_at=>{}}
+        GlAccount.exported_associations = {}
+    end
+
+    def test_blacklisting
+        assert Skr::GlAccount.json_attribute_is_allowed?(:name)
+        assert Skr::GlAccount.json_attribute_is_allowed?('name')
+
+        GlAccount.send :blacklist_json_attributes, :name
+        refute Skr::GlAccount.json_attribute_is_allowed?('name')
+    end
+
+    def test_whitelisting
+
+        refute Skr::GlAccount.json_attribute_is_allowed?('updated_at')
+        GlAccount.send :whitelist_json_attributes, :updated_at
+        assert Skr::GlAccount.json_attribute_is_allowed?('updated_at')
+    end
+
+end

data/test/concerns/pub_sub_test.rb

@@ -0,0 +1,83 @@
+require_relative '../test_helper'
+
+class PubSubTest < Skr::TestCase
+
+    class EventTester
+        def self.after_save(*args);    end
+        def self.after_create(*args);  end
+        def self.after_update(*args);  end
+        def self.after_destroy(*args); end
+
+        include Skr::Concerns::PubSub
+
+        def trigger( event, *args )
+            fire_event(event, *args )
+        end
+    end
+
+    class Ev1 < EventTester
+        has_additional_events :test_one
+    end
+
+    class Ev2 < EventTester
+        has_additional_events :test_two
+    end
+
+
+    def test_event_name_registration
+        assert_equal [ :save, :create, :update, :destroy ],EventTester.valid_event_names
+        assert_equal [ :save, :create, :update, :destroy, :test_one ],Ev1.valid_event_names
+    end
+
+    def test_only_valid
+        assert_raises( EventTester::InvalidEvent) do
+            EventTester.observe(:invalid_event) do | ev |
+            end
+        end
+        assert_raises( EventTester::InvalidEvent) do
+            EventTester.observe(:save) do | ev |
+            end
+            EventTester.new.trigger(:invalid_event)
+        end
+        assert_raises( EventTester::InvalidEvent) do
+            Ev1.observe(:test_two) do | ev |
+            end
+        end
+        assert_raises( EventTester::InvalidEvent) do
+            Ev2.observe(:test_one) do | ev |
+            end
+        end
+        begin
+            Ev2.observe(:test_one) do | ev |
+            end
+        rescue EventTester::InvalidEvent=>e
+            assert_equal 'test_one is not a valid event for PubSubTest::Ev2', e.to_s
+        end
+    end
+
+    def test_subscription
+        EventTester.observe(:save) do | ev |
+        end
+    end
+    def test_firing
+        results=[]
+        Ev1.observe(:test_one) do | ev, one, two |
+            results = [ ev, one, two ]
+        end
+        evt=Ev1.new
+        evt.trigger( :test_one, 3, 5 )
+        assert_equal [ evt, 3, 5 ], results
+
+        evt.trigger( :test_one, 'foo' )
+        assert_equal [ evt, 'foo', nil ], results
+    end
+
+
+    def test_firing_with_assertsions
+        assert_event_fires( Ev1, :test_one ) do
+            Ev1.new.trigger( :test_one, 3, 5 )
+        end
+        assert_equal [ 3, 5 ], last_event_results[1..-1]
+    end
+
+end

data/test/concerns/sanitize_json_test.rb

@@ -0,0 +1,47 @@
+require_relative '../test_helper'
+
+
+class SanitizeJsonTest < Skr::TestCase
+
+
+    def teardown
+        GlAccount.whitelisted_json_attributes = {}
+        GlAccount.blacklisted_json_attributes = {}
+        GlAccount.exported_associations = {}
+        GlPosting.blacklisted_json_attributes = {}
+    end
+
+    def test_unknown_attribute_removal
+        data = { name: 'CASH', number: '1200', drop_table: 'users' }
+        json = Skr::GlAccount.sanitize_json(data)
+        assert_equal data.except(:drop_table), json
+    end
+
+    def test_cleaning_unwanted_attributes
+        data = { name: 'CASH', number: '1200',credits: [] }
+        json = Skr::GlAccount.sanitize_json(data)
+        data.delete(:credits)
+        assert_equal data, json
+    end
+
+    def test_exported_associations
+        data = { foo: 'bar', description: 'a test', debits: [], credits: [] }
+        json = Skr::GlTransaction.sanitize_json(data)
+        assert_equal( { description: 'a test', debits_attributes: [], credits_attributes: [] }, json )
+    end
+
+    def test_blacklisted_attributes
+        GlAccount.send :blacklist_json_attributes, :name
+        data = { name: 'CASH', number: '1200' }
+        json = Skr::GlAccount.sanitize_json(data)
+        data.delete( :name )
+        assert_equal data, json
+    end
+
+    def test_recursive_cleaning
+        data = { gl_transaction: { source: 'unk', credits: [ { account_number: '120001' } ] } }
+        json = GlManualEntry.sanitize_json(data)
+        assert_equal( { gl_transaction_attributes: { credits_attributes: [ { account_number: '120001' } ] } }, json )
+    end
+
+end

data/test/core/configuration_test.rb

@@ -0,0 +1,24 @@
+require_relative '../test_helper'
+
+describe Skr::Core::Configuration do
+
+    def test_default_values
+        conf = Skr::Core::DefaultConfiguration.new
+        Skr::Core.silence_logs do
+            assert_equal '01', conf.default_branch_code
+            assert_equal '01', Skr::Core.config.default_branch_code
+        end
+    end
+
+    def test_changing_values_are_logged
+        begin
+            assert_logs_matching( /default_branch_code changed from 01 to 02/ ) do
+                Skr::Core.config.default_branch_code='02'
+            end
+        ensure
+            Skr::Core.silence_logs {   Skr::Core.config.default_branch_code='01' }
+        end
+    end
+
+
+end

data/test/core/numbers_test.rb

@@ -0,0 +1,26 @@
+require_relative '../test_helper'
+
+describe Skr::Core::Numbers do
+
+    Num = Skr::Core::Numbers
+
+
+    def test_percnum
+        assert Num::PercNum.new( '5%'  ).is_percentage?, "is a percentage"
+        assert Num::PercNum.new( '5% ' ).is_percentage?, "is a percentage"
+        assert Num::PercNum.new( '5.3 % ' ).is_percentage?, "is a percentage"
+        refute Num::PercNum.new( '$5.3 ' ).is_percentage?, "is not a percentage"
+        # this is debatable, but we have to draw the line somewhere
+        refute Num::PercNum.new( '%5.3 ' ).is_percentage?, "is a percentage"
+
+        assert_equal '95.0',  Num::PercNum.new( '5'  ).debit_from(100).to_s
+        assert_equal '95.0',  Num::PercNum.new( '5%' ).debit_from(100).to_s
+        assert_equal '105.0', Num::PercNum.new( '5%' ).credit_to(100).to_s
+        assert_equal '95.0',  Num::PercNum.new( '-5%').credit_to(100).to_s
+
+        assert_equal '137.38449', Num::PercNum.new( '33.383%' ).credit_to(103).to_s
+        assert_equal '68.61551',  Num::PercNum.new( '33.383%' ).debit_from(103).to_s
+    end
+
+
+end

data/test/core/strings_test.rb

@@ -0,0 +1,41 @@
+require_relative '../test_helper'
+
+describe Skr::Core::Strings do
+
+    # just 'cuz
+    Str = Skr::Core::Strings
+
+    def test_random_is_of_proper_length
+        assert_equal 12, Str.random.length
+        assert_equal 6, Str.random(6).length
+    end
+
+    def test_random_doesnt_use_bad_chars
+        bad = Str::BAD_RAND_CHARS
+        assert bad.present?, 'list of bad random chars is empty'
+        0.upto(10).each do | i |
+            string = Str.random
+            string.each_char do |c|
+                refute bad.include?(c), "Random string #{string} included bad char '#{c}'"
+            end
+        end
+    end
+
+    def test_code_identifier_shortens
+        # if all words are long engouth to shorten, then it takes an
+        # equal number from each
+        assert_equal 'GENACMCORP', Str.code_identifier( 'General Acme Corp' )
+        # If one word is too short, it'll attempt to make up the difference with
+        # later words
+        assert_equal 'GENIINCORP', Str.code_identifier( 'General I Incorporated' )
+        # If it gets to the end and it's still too short, it'll append the
+        # padding char
+        assert_equal 'GENERALIBC', Str.code_identifier( 'General I BC' )
+        assert_equal 'GENERALIB*', Str.code_identifier( 'General I B.', padding: '*' )
+        assert_equal 'FSANSEYEAG', Str.code_identifier( 'Four score and seven years ago', padding: '*' )
+        assert_equal 'ALONSBEAST', Str.code_identifier( 'A long s beasty' )
+        assert_equal 'GE', Str.code_identifier( 'GE', padding: false )
+        assert_equal 'HI33ME', Str.code_identifier( 'Hi 33 Me!', padding: false )
+        assert_equal 'BADIANDOCO', Str.code_identifier( "Bayer, Dickinson and O'Conner", padding: false )
+    end
+end